@deepraxis/sdk 0.1.1-dev.fcdebee → 0.1.1-dev.fee48ec

package/dist/resources.generated.d.ts

@@ -1793,6 +1793,20 @@ export declare function createAgent(transport: Transport): {
             type: "computer_deleted";
         }>;
         files: {
+            convert: {
+                create: (options: import("./core/transport.js").CallOptions<Types.ComputersFilesConvertData>) => Promise<{
+                    type: "computer";
+                    id: string;
+                    name: string;
+                    sandbox_id: string | null;
+                    machine_state: "not_started" | "provisioned";
+                    environment_id: string | null;
+                    status: "active" | "archived";
+                    created_at: string;
+                    updated_at: string;
+                    archived_at: string | null;
+                }>;
+            };
             list: (options: import("./core/transport.js").CallOptions<Types.ComputersFilesListData>) => Promise<{
                 data: Array<{
                     path: string;
@@ -3956,6 +3970,40 @@ export declare function createBrowser(transport: Transport): {
         retrieve: (options?: import("./core/transport.js").CallOptions<Types.BrowserSeleniumUnsupportedData> | undefined) => Promise<unknown>;
     };
     sessions: {
+        actions: {
+            create: (options: import("./core/transport.js").CallOptions<Types.BrowserRunPageActionData>) => Promise<{
+                type: "open" | "click" | "fill" | "press" | "scroll" | "back" | "forward" | "reload";
+                tab: string;
+                url: string;
+                title: string;
+            } | {
+                type: "tabs.list";
+                tabs: Array<{
+                    id: string;
+                    url: string;
+                    title: string;
+                    active: boolean;
+                }>;
+            } | {
+                type: "snapshot";
+                tab: string;
+                url: string;
+                title: string;
+                snapshot: string;
+                refs: number;
+                truncated: boolean;
+            } | {
+                type: "screenshot";
+                tab: string;
+                mediaType: "image/png";
+                data: string;
+                bytes: number;
+            } | {
+                type: "evaluate";
+                tab: string;
+                value: unknown;
+            }>;
+        };
         create: (options: import("./core/transport.js").CallOptions<Types.BrowserCreateSessionData>) => Promise<Types.BrowserSessionCreateResult>;
         events: {
             list: (options: import("./core/transport.js").CallOptions<Types.BrowserListEventsData>) => Promise<{
@@ -4076,7 +4124,9 @@ export declare function createCut(transport: Transport): {
     };
     projects: {
         analysis: {
-            create: (options: import("./core/transport.js").CallOptions<Types.CutCreateAnalysisData>) => Promise<Types.CutAnalysisResult>;
+            create: (options: import("./core/transport.js").CallOptions<Types.CutCreateAnalysisData>) => Promise<{
+                kind: "cut-AnalysisResult";
+            } & Types.CutAnalysisResult>;
         };
         bindings: {
             create: (options: import("./core/transport.js").CallOptions<Types.CutCreateBindingData>) => Promise<Types.CutBinding>;
@@ -4097,6 +4147,9 @@ export declare function createCut(transport: Transport): {
         media: {
             import: (options: import("./core/transport.js").CallOptions<Types.CutImportMediaData>) => Promise<Types.CutImportedMedia>;
         };
+        renders: {
+            create: (options: import("./core/transport.js").CallOptions<Types.CutCreateRenderData>) => Promise<Types.CutDraftRender>;
+        };
         retrieve: (options: import("./core/transport.js").CallOptions<Types.CutRetrieveProjectData>) => Promise<Types.CutProjectDetail>;
         retrieveState: (options: import("./core/transport.js").CallOptions<Types.CutRetrieveStateData>) => Promise<Types.CutState>;
         retrieveTimeline: (options: import("./core/transport.js").CallOptions<Types.CutRetrieveTimelineData>) => Promise<Types.CutTimelineResult>;
@@ -4107,6 +4160,9 @@ export declare function createCut(transport: Transport): {
             list: (options: import("./core/transport.js").CallOptions<Types.CutListVersionsData>) => Promise<Types.CutVersionPage>;
         };
     };
+    renders: {
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.CutRetrieveRenderData>) => Promise<Types.CutDraftRender>;
+    };
     versions: {
         restore: (options: import("./core/transport.js").CallOptions<Types.CutRestoreVersionData>) => Promise<Types.CutTransaction>;
     };
@@ -4156,6 +4212,49 @@ export declare function createDatabase(transport: Transport): {
         update: (options: import("./core/transport.js").CallOptions<Types.DatabaseUpdateDatabaseData>) => Promise<Types.DatabaseDatabase>;
     };
 };
+export declare function createDevops(transport: Transport): {
+    projects: {
+        retrieveTestCatalog: (options: import("./core/transport.js").CallOptions<Types.DevopsTestCatalogGetData>) => Promise<Types.DevopsCatalogVersion>;
+        testCases: {
+            list: (options: import("./core/transport.js").CallOptions<Types.DevopsTestCasesListData>) => Promise<Types.DevopsTestCasePage>;
+        };
+        testPlans: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansCreateData>) => Promise<Types.DevopsPlan>;
+            list: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansListData>) => Promise<Types.DevopsPlanPage>;
+        };
+        testReports: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DevopsTestReportsUploadData>) => Promise<Types.DevopsReportUpload>;
+        };
+        testRuns: {
+            create: (options: import("./core/transport.js").CallOptions<Types.DevopsTestRunsCreateData>) => Promise<Types.DevopsRun>;
+            list: (options: import("./core/transport.js").CallOptions<Types.DevopsTestRunsListData>) => Promise<Types.DevopsRunPage>;
+        };
+        testSuites: {
+            list: (options: import("./core/transport.js").CallOptions<Types.DevopsTestSuitesListData>) => Promise<Types.DevopsSuitePage>;
+        };
+    };
+    testCases: {
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DevopsTestCasesGetData>) => Promise<Types.DevopsTestCase>;
+    };
+    testPlans: {
+        delete: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansDeleteData>) => Promise<Types.DevopsPlanDeleted>;
+        pause: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansPauseData>) => Promise<Types.DevopsPlan>;
+        resume: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansResumeData>) => Promise<Types.DevopsPlan>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansGetData>) => Promise<Types.DevopsPlan>;
+        update: (options: import("./core/transport.js").CallOptions<Types.DevopsTestPlansUpdateData>) => Promise<Types.DevopsPlan>;
+    };
+    testRuns: {
+        cancel: (options: import("./core/transport.js").CallOptions<Types.DevopsTestRunsCancelData>) => Promise<Types.DevopsRun>;
+        executions: {
+            list: (options: import("./core/transport.js").CallOptions<Types.DevopsTestExecutionsListData>) => Promise<Types.DevopsExecutionPage>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.DevopsTestExecutionsGetData>) => Promise<Types.DevopsExecution>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DevopsTestRunsGetData>) => Promise<Types.DevopsRun>;
+    };
+    testSuites: {
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.DevopsTestSuitesGetData>) => Promise<Types.DevopsSuite>;
+    };
+};
 export declare function createFile(transport: Transport): {
     files: {
         contentLinks: {
@@ -4183,6 +4282,7 @@ export declare function createFile(transport: Transport): {
         parts: {
             create: (options: import("./core/transport.js").CallOptions<Types.FileAddUploadPartData>) => Promise<Types.OwnFilePraxisUploadPart>;
         };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.FileRetrieveUploadData>) => Promise<Types.OwnFilePraxisUpload>;
     };
 };
 export declare function createKnowledge(transport: Transport): {
@@ -4857,6 +4957,36 @@ export declare function createModel(transport: Transport): {
         retrieveContent: (options: import("./core/transport.js").CallOptions<Types.DownloadVideoContentData>) => Promise<Blob | File>;
     };
 };
+export declare function createOntology(transport: Transport): {
+    changesets: {
+        create: (options: import("./core/transport.js").CallOptions<Types.OntologyApplyChangesetData>) => Promise<Types.OntologyChangesetResult>;
+    };
+    nodes: {
+        create: (options: import("./core/transport.js").CallOptions<Types.OntologyCreateNodeData>) => Promise<Types.OntologyNode>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.OntologyListNodesData> | undefined) => Promise<import("./automation.js").Page<Types.OntologyNode | Types.OntologyRestrictedNode>>;
+        merge: {
+            create: (options: import("./core/transport.js").CallOptions<Types.OntologyMergeNodeData>) => Promise<Types.OntologyNode>;
+        };
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.OntologyRetrieveNodeData>) => Promise<Types.OntologyNodeWithRelations>;
+        update: (options: import("./core/transport.js").CallOptions<Types.OntologyUpdateNodeData>) => Promise<Types.OntologyNode>;
+    };
+    relations: {
+        create: (options: import("./core/transport.js").CallOptions<Types.OntologyCreateRelationData>) => Promise<Types.OntologyRelation>;
+        invalidate: {
+            create: (options: import("./core/transport.js").CallOptions<Types.OntologyInvalidateRelationData>) => Promise<Types.OntologyRelation>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.OntologyListRelationsData> | undefined) => Promise<import("./automation.js").Page<Types.OntologyRelation>>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.OntologyRetrieveRelationData>) => Promise<Types.OntologyRelation>;
+    };
+    search: {
+        create: (options: import("./core/transport.js").CallOptions<Types.OntologySearchData>) => Promise<Types.OntologySearchResult>;
+    };
+    types: {
+        create: (options: import("./core/transport.js").CallOptions<Types.OntologyRegisterTypeData>) => Promise<unknown>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.OntologyListTypesData> | undefined) => Promise<Types.OntologyTypeRegistrationPage>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.OntologyRetrieveTypeData>) => Promise<Types.OntologyTypeLookup>;
+    };
+};
 export declare function createOrganization(transport: Transport): {
     charges: {
         list: (options: import("./core/transport.js").CallOptions<Types.ExportOrganizationChargesData>) => Promise<{
@@ -5355,6 +5485,85 @@ export declare function createSearch(transport: Transport): {
         }>;
     };
 };
+export declare function createStudio(transport: Transport): {
+    codexes: {
+        create: (options: import("./core/transport.js").CallOptions<Types.StudioCodexesCreateData>) => Promise<Types.StudioCodex>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.StudioCodexesDeleteData>) => Promise<Types.StudioDeleted>;
+        entries: {
+            create: (options: import("./core/transport.js").CallOptions<Types.StudioEntriesCreateData>) => Promise<Types.StudioEntry>;
+            delete: (options: import("./core/transport.js").CallOptions<Types.StudioEntriesDeleteData>) => Promise<Types.StudioDeleted>;
+            list: (options: import("./core/transport.js").CallOptions<Types.StudioEntriesListData>) => Promise<Types.StudioEntryPage>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioEntriesGetData>) => Promise<Types.StudioEntry>;
+            update: (options: import("./core/transport.js").CallOptions<Types.StudioEntriesUpdateData>) => Promise<Types.StudioEntry>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioCodexesListData> | undefined) => Promise<Types.StudioCodexPage>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioCodexesGetData>) => Promise<Types.StudioCodex>;
+        update: (options: import("./core/transport.js").CallOptions<Types.StudioCodexesUpdateData>) => Promise<Types.StudioCodex>;
+    };
+    genres: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioGenresListData> | undefined) => Promise<Types.StudioGenreList>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioGenresGetData>) => Promise<Types.StudioGenreDetail>;
+    };
+    platforms: {
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioPlatformsListData> | undefined) => Promise<Types.StudioPlatformList>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioPlatformsGetData>) => Promise<Types.StudioPlatform>;
+    };
+    styles: {
+        create: (options: import("./core/transport.js").CallOptions<Types.StudioStylesCreateData>) => Promise<Types.StudioStyle>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.StudioStylesDeleteData>) => Promise<Types.StudioDeleted>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioStylesListData> | undefined) => Promise<Types.StudioStylePage>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioStylesGetData>) => Promise<Types.StudioStyle>;
+        update: (options: import("./core/transport.js").CallOptions<Types.StudioStylesUpdateData>) => Promise<Types.StudioStyle>;
+    };
+    templates: {
+        create: (options: import("./core/transport.js").CallOptions<Types.StudioTemplatesCreateData>) => Promise<Types.StudioTemplate>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.StudioTemplatesDeleteData>) => Promise<Types.StudioDeleted>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioTemplatesListData> | undefined) => Promise<Types.StudioTemplatePage>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioTemplatesGetData>) => Promise<Types.StudioTemplate>;
+    };
+    themes: {
+        create: (options: import("./core/transport.js").CallOptions<Types.StudioThemesCreateData>) => Promise<Types.StudioTheme>;
+        delete: (options: import("./core/transport.js").CallOptions<Types.StudioThemesDeleteData>) => Promise<Types.StudioDeleted>;
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioThemesListData> | undefined) => Promise<Types.StudioThemePage>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioThemesGetData>) => Promise<Types.StudioTheme>;
+        update: (options: import("./core/transport.js").CallOptions<Types.StudioThemesUpdateData>) => Promise<Types.StudioTheme>;
+    };
+    works: {
+        create: (options: import("./core/transport.js").CallOptions<Types.StudioWorksCreateData>) => Promise<Types.StudioWork>;
+        drafts: {
+            create: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsCreateData>) => Promise<Types.StudioDraftDetail>;
+            list: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsListData>) => Promise<Types.StudioDraftList>;
+            rebase: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsRebaseData>) => Promise<Types.StudioDraftWriteResult>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsGetData>) => Promise<Types.StudioDraftDetail>;
+            retrieveExport: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsExportData>) => Promise<Types.StudioExportResult>;
+            retrieveOutline: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsOutlineData>) => Promise<Types.StudioOutlineResult>;
+            retrieveReview: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsReviewData>) => Promise<Types.StudioReviewReport>;
+            status: {
+                list: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsStatusData>) => Promise<Types.StudioDraftStatus>;
+            };
+            units: {
+                batchCreate: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsBatchCreateData>) => Promise<Types.StudioUnitListWriteResult>;
+                batchUpdate: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsBatchUpdateData>) => Promise<Types.StudioUnitListWriteResult>;
+                create: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsCreateData>) => Promise<Types.StudioUnitWriteResult>;
+            };
+            update: (options: import("./core/transport.js").CallOptions<Types.StudioDraftsUpdateData>) => Promise<Types.StudioDraftWriteResult>;
+        };
+        list: (options?: import("./core/transport.js").CallOptions<Types.StudioWorksListData> | undefined) => Promise<Types.StudioWorkPage>;
+        resolve: (options: import("./core/transport.js").CallOptions<Types.StudioWorksResolveData>) => Promise<Types.StudioResolveResult>;
+        retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioWorksGetData>) => Promise<Types.StudioWorkDetail>;
+        units: {
+            blocks: {
+                patch: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsPatchBlocksData>) => Promise<Types.StudioBlocksWriteResult>;
+            };
+            move: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsMoveData>) => Promise<Types.StudioUnitWriteResult>;
+            retrieve: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsGetData>) => Promise<Types.StudioUnitContent>;
+            retrieveContext: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsContextData>) => Promise<Types.StudioContextPack>;
+            update: (options: import("./core/transport.js").CallOptions<Types.StudioUnitsUpdateData>) => Promise<Types.StudioUnitWriteResult>;
+        };
+        update: (options: import("./core/transport.js").CallOptions<Types.StudioWorksUpdateData>) => Promise<Types.StudioWorkWriteResult>;
+        updateBrief: (options: import("./core/transport.js").CallOptions<Types.StudioWorksUpdateBriefData>) => Promise<Types.StudioBriefWriteResult>;
+    };
+};
 export declare function createTicket(transport: Transport): {
     activity: {
         retrieve: (options?: import("./core/transport.js").CallOptions<Types.TicketGetActivityData> | undefined) => Promise<{
@@ -5533,14 +5742,17 @@ export declare const resourceFactories: {
     crm: typeof createCrm;
     cut: typeof createCut;
     database: typeof createDatabase;
+    devops: typeof createDevops;
     file: typeof createFile;
     knowledge: typeof createKnowledge;
     media: typeof createMedia;
     meta: typeof createMeta;
     model: typeof createModel;
+    ontology: typeof createOntology;
     organization: typeof createOrganization;
     sandbox: typeof createSandbox;
     search: typeof createSearch;
+    studio: typeof createStudio;
     ticket: typeof createTicket;
     vault: typeof createVault;
 };

package/dist/resources.generated.js

@@ -55,6 +55,9 @@ export function createAgent(transport) {
             create: bind(transport, sdk.computersCreate),
             delete: bind(transport, sdk.computersDelete),
             files: {
+                convert: {
+                    create: bind(transport, sdk.computersFilesConvert),
+                },
                 list: bind(transport, sdk.computersFilesList),
                 retrieveContent: bind(transport, sdk.computersFilesContent),
             },
@@ -363,6 +366,9 @@ export function createBrowser(transport) {
             retrieve: bind(transport, sdk.browserSeleniumUnsupported),
         },
         sessions: {
+            actions: {
+                create: bind(transport, sdk.browserRunPageAction),
+            },
             create: bind(transport, sdk.browserCreateSession),
             events: {
                 list: bind(transport, sdk.browserListEvents),
@@ -502,6 +508,9 @@ export function createCut(transport) {
             media: {
                 import: bind(transport, sdk.cutImportMedia),
             },
+            renders: {
+                create: bind(transport, sdk.cutCreateRender),
+            },
             retrieve: bind(transport, sdk.cutRetrieveProject),
             retrieveState: bind(transport, sdk.cutRetrieveState),
             retrieveTimeline: bind(transport, sdk.cutRetrieveTimeline),
@@ -512,6 +521,9 @@ export function createCut(transport) {
                 list: bind(transport, sdk.cutListVersions),
             },
         },
+        renders: {
+            retrieve: bind(transport, sdk.cutRetrieveRender),
+        },
         versions: {
             restore: bind(transport, sdk.cutRestoreVersion),
         },
@@ -554,6 +566,51 @@ export function createDatabase(transport) {
         },
     };
 }
+export function createDevops(transport) {
+    return {
+        projects: {
+            retrieveTestCatalog: bind(transport, sdk.devopsTestCatalogGet),
+            testCases: {
+                list: bind(transport, sdk.devopsTestCasesList),
+            },
+            testPlans: {
+                create: bind(transport, sdk.devopsTestPlansCreate),
+                list: bind(transport, sdk.devopsTestPlansList),
+            },
+            testReports: {
+                create: bind(transport, sdk.devopsTestReportsUpload),
+            },
+            testRuns: {
+                create: bind(transport, sdk.devopsTestRunsCreate),
+                list: bind(transport, sdk.devopsTestRunsList),
+            },
+            testSuites: {
+                list: bind(transport, sdk.devopsTestSuitesList),
+            },
+        },
+        testCases: {
+            retrieve: bind(transport, sdk.devopsTestCasesGet),
+        },
+        testPlans: {
+            delete: bind(transport, sdk.devopsTestPlansDelete),
+            pause: bind(transport, sdk.devopsTestPlansPause),
+            resume: bind(transport, sdk.devopsTestPlansResume),
+            retrieve: bind(transport, sdk.devopsTestPlansGet),
+            update: bind(transport, sdk.devopsTestPlansUpdate),
+        },
+        testRuns: {
+            cancel: bind(transport, sdk.devopsTestRunsCancel),
+            executions: {
+                list: bind(transport, sdk.devopsTestExecutionsList),
+                retrieve: bind(transport, sdk.devopsTestExecutionsGet),
+            },
+            retrieve: bind(transport, sdk.devopsTestRunsGet),
+        },
+        testSuites: {
+            retrieve: bind(transport, sdk.devopsTestSuitesGet),
+        },
+    };
+}
 export function createFile(transport) {
     return {
         files: {
@@ -577,6 +634,7 @@ export function createFile(transport) {
             parts: {
                 create: bind(transport, options => sdk.fileAddUploadPart({ ...options, bodySerializer: multipartBodySerializer, headers: { 'Content-Type': null, ...options.headers } })),
             },
+            retrieve: bind(transport, sdk.fileRetrieveUpload),
         },
     };
 }
@@ -804,6 +862,38 @@ export function createModel(transport) {
         },
     };
 }
+export function createOntology(transport) {
+    return {
+        changesets: {
+            create: bind(transport, sdk.ontologyApplyChangeset),
+        },
+        nodes: {
+            create: bind(transport, sdk.ontologyCreateNode),
+            list: bindPage(transport, sdk.ontologyListNodes),
+            merge: {
+                create: bind(transport, sdk.ontologyMergeNode),
+            },
+            retrieve: bind(transport, sdk.ontologyRetrieveNode),
+            update: bind(transport, sdk.ontologyUpdateNode),
+        },
+        relations: {
+            create: bind(transport, sdk.ontologyCreateRelation),
+            invalidate: {
+                create: bind(transport, sdk.ontologyInvalidateRelation),
+            },
+            list: bindPage(transport, sdk.ontologyListRelations),
+            retrieve: bind(transport, sdk.ontologyRetrieveRelation),
+        },
+        search: {
+            create: bind(transport, sdk.ontologySearch),
+        },
+        types: {
+            create: bind(transport, sdk.ontologyRegisterType),
+            list: bind(transport, sdk.ontologyListTypes),
+            retrieve: bind(transport, sdk.ontologyRetrieveType),
+        },
+    };
+}
 export function createOrganization(transport) {
     return {
         charges: {
@@ -925,6 +1015,87 @@ export function createSearch(transport) {
         },
     };
 }
+export function createStudio(transport) {
+    return {
+        codexes: {
+            create: bind(transport, sdk.studioCodexesCreate),
+            delete: bind(transport, sdk.studioCodexesDelete),
+            entries: {
+                create: bind(transport, sdk.studioEntriesCreate),
+                delete: bind(transport, sdk.studioEntriesDelete),
+                list: bind(transport, sdk.studioEntriesList),
+                retrieve: bind(transport, sdk.studioEntriesGet),
+                update: bind(transport, sdk.studioEntriesUpdate),
+            },
+            list: bind(transport, sdk.studioCodexesList),
+            retrieve: bind(transport, sdk.studioCodexesGet),
+            update: bind(transport, sdk.studioCodexesUpdate),
+        },
+        genres: {
+            list: bind(transport, sdk.studioGenresList),
+            retrieve: bind(transport, sdk.studioGenresGet),
+        },
+        platforms: {
+            list: bind(transport, sdk.studioPlatformsList),
+            retrieve: bind(transport, sdk.studioPlatformsGet),
+        },
+        styles: {
+            create: bind(transport, sdk.studioStylesCreate),
+            delete: bind(transport, sdk.studioStylesDelete),
+            list: bind(transport, sdk.studioStylesList),
+            retrieve: bind(transport, sdk.studioStylesGet),
+            update: bind(transport, sdk.studioStylesUpdate),
+        },
+        templates: {
+            create: bind(transport, sdk.studioTemplatesCreate),
+            delete: bind(transport, sdk.studioTemplatesDelete),
+            list: bind(transport, sdk.studioTemplatesList),
+            retrieve: bind(transport, sdk.studioTemplatesGet),
+        },
+        themes: {
+            create: bind(transport, sdk.studioThemesCreate),
+            delete: bind(transport, sdk.studioThemesDelete),
+            list: bind(transport, sdk.studioThemesList),
+            retrieve: bind(transport, sdk.studioThemesGet),
+            update: bind(transport, sdk.studioThemesUpdate),
+        },
+        works: {
+            create: bind(transport, sdk.studioWorksCreate),
+            drafts: {
+                create: bind(transport, sdk.studioDraftsCreate),
+                list: bind(transport, sdk.studioDraftsList),
+                rebase: bind(transport, sdk.studioDraftsRebase),
+                retrieve: bind(transport, sdk.studioDraftsGet),
+                retrieveExport: bind(transport, sdk.studioDraftsExport),
+                retrieveOutline: bind(transport, sdk.studioDraftsOutline),
+                retrieveReview: bind(transport, sdk.studioDraftsReview),
+                status: {
+                    list: bind(transport, sdk.studioDraftsStatus),
+                },
+                units: {
+                    batchCreate: bind(transport, sdk.studioUnitsBatchCreate),
+                    batchUpdate: bind(transport, sdk.studioUnitsBatchUpdate),
+                    create: bind(transport, sdk.studioUnitsCreate),
+                },
+                update: bind(transport, sdk.studioDraftsUpdate),
+            },
+            list: bind(transport, sdk.studioWorksList),
+            resolve: bind(transport, sdk.studioWorksResolve),
+            retrieve: bind(transport, sdk.studioWorksGet),
+            units: {
+                blocks: {
+                    patch: bind(transport, sdk.studioUnitsPatchBlocks),
+                },
+                move: bind(transport, sdk.studioUnitsMove),
+                retrieve: bind(transport, sdk.studioUnitsGet),
+                retrieveContext: bind(transport, sdk.studioUnitsContext),
+                update: bind(transport, sdk.studioUnitsUpdate),
+            },
+            update: bind(transport, sdk.studioWorksUpdate),
+            updateBrief: bind(transport, sdk.studioWorksUpdateBrief),
+        },
+    };
+}
 export function createTicket(transport) {
     return {
         activity: {
@@ -1065,14 +1236,17 @@ export const resourceFactories = {
     crm: createCrm,
     cut: createCut,
     database: createDatabase,
+    devops: createDevops,
     file: createFile,
     knowledge: createKnowledge,
     media: createMedia,
     meta: createMeta,
     model: createModel,
+    ontology: createOntology,
     organization: createOrganization,
     sandbox: createSandbox,
     search: createSearch,
+    studio: createStudio,
     ticket: createTicket,
     vault: createVault,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepraxis/sdk",
-  "version": "0.1.1-dev.fcdebee",
+  "version": "0.1.1-dev.fee48ec",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -27,7 +27,7 @@
     "LICENSE",
     "METHODS.md"
   ],
-  "description": "TypeScript SDK for the Praxis (知行云) API: models, agents, sandboxes, search, data and automation.",
+  "description": "TypeScript SDK for the Praxis API: models, agents, sandboxes, search, data and automation.",
   "license": "Apache-2.0",
   "homepage": "https://deepraxis.com",
   "keywords": [