windmill-client 0.1.0 → 0.2.0

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "0.1.0",
+  "version": "0.2.0",
+  "author": "Ruben Fiszel",
+  "license": "Apache 2.0",
   "dependencies": {},
-  "devDependencies": {}
+  "devDependencies": {},
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "prepublish": "tsc"
 }

package/src/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/src/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/src/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/src/core/CancelablePromise.d.ts

@@ -0,0 +1,26 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    readonly [Symbol.toStringTag]: string;
+    private _isResolved;
+    private _isRejected;
+    private _isCancelled;
+    private readonly _cancelHandlers;
+    private readonly _promise;
+    private _resolve?;
+    private _reject?;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/src/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string>;
+    USERNAME?: string | Resolver<string>;
+    PASSWORD?: string | Resolver<string>;
+    HEADERS?: Headers | Resolver<Headers>;
+    ENCODE_PATH?: (path: string) => string;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/src/core/request.d.ts

@@ -0,0 +1,13 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare const sendRequest: (config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Headers, onCancel: OnCancel) => Promise<Response>;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;

package/src/index.d.ts

@@ -0,0 +1,95 @@
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI } from './core/OpenAPI';
+export type { OpenAPIConfig } from './core/OpenAPI';
+export { AppWithLastVersion } from './models/AppWithLastVersion';
+export type { AppWithLastVersionWDraft } from './models/AppWithLastVersionWDraft';
+export { AuditLog } from './models/AuditLog';
+export type { BranchAll } from './models/BranchAll';
+export type { BranchOne } from './models/BranchOne';
+export { CompletedJob } from './models/CompletedJob';
+export type { ContextualVariable } from './models/ContextualVariable';
+export type { CreateInput } from './models/CreateInput';
+export type { CreateResource } from './models/CreateResource';
+export type { CreateVariable } from './models/CreateVariable';
+export type { CreateWorkspace } from './models/CreateWorkspace';
+export type { EditResource } from './models/EditResource';
+export type { EditResourceType } from './models/EditResourceType';
+export type { EditSchedule } from './models/EditSchedule';
+export type { EditVariable } from './models/EditVariable';
+export type { EditWorkspaceUser } from './models/EditWorkspaceUser';
+export type { Flow } from './models/Flow';
+export type { FlowMetadata } from './models/FlowMetadata';
+export type { FlowModule } from './models/FlowModule';
+export type { FlowModuleValue } from './models/FlowModuleValue';
+export type { FlowPreview } from './models/FlowPreview';
+export type { FlowStatus } from './models/FlowStatus';
+export { FlowStatusModule } from './models/FlowStatusModule';
+export type { FlowValue } from './models/FlowValue';
+export type { Folder } from './models/Folder';
+export type { ForloopFlow } from './models/ForloopFlow';
+export { GlobalUserInfo } from './models/GlobalUserInfo';
+export type { Group } from './models/Group';
+export type { Identity } from './models/Identity';
+export type { Input } from './models/Input';
+export type { InputTransform } from './models/InputTransform';
+export type { JavascriptTransform } from './models/JavascriptTransform';
+export { Job } from './models/Job';
+export { ListableApp } from './models/ListableApp';
+export type { ListableResource } from './models/ListableResource';
+export type { ListableVariable } from './models/ListableVariable';
+export type { Login } from './models/Login';
+export { MainArgSignature } from './models/MainArgSignature';
+export type { NewSchedule } from './models/NewSchedule';
+export { NewScript } from './models/NewScript';
+export type { NewScriptWithDraft } from './models/NewScriptWithDraft';
+export type { NewToken } from './models/NewToken';
+export type { NewTokenImpersonate } from './models/NewTokenImpersonate';
+export type { NewUser } from './models/NewUser';
+export type { OpenFlow } from './models/OpenFlow';
+export type { OpenFlowWPath } from './models/OpenFlowWPath';
+export type { PathFlow } from './models/PathFlow';
+export type { PathScript } from './models/PathScript';
+export { Policy } from './models/Policy';
+export { Preview } from './models/Preview';
+export { QueuedJob } from './models/QueuedJob';
+export { RawScript } from './models/RawScript';
+export type { Resource } from './models/Resource';
+export type { ResourceType } from './models/ResourceType';
+export type { Retry } from './models/Retry';
+export { RunnableType } from './models/RunnableType';
+export type { Schedule } from './models/Schedule';
+export { Script } from './models/Script';
+export type { ScriptArgs } from './models/ScriptArgs';
+export type { SlackToken } from './models/SlackToken';
+export type { StaticTransform } from './models/StaticTransform';
+export type { TokenResponse } from './models/TokenResponse';
+export type { TruncatedToken } from './models/TruncatedToken';
+export type { UpdateInput } from './models/UpdateInput';
+export type { Usage } from './models/Usage';
+export type { User } from './models/User';
+export type { UserWorkspaceList } from './models/UserWorkspaceList';
+export type { WorkerPing } from './models/WorkerPing';
+export type { Workspace } from './models/Workspace';
+export type { WorkspaceInvite } from './models/WorkspaceInvite';
+export { AdminService } from './services/AdminService';
+export { AppService } from './services/AppService';
+export { AuditService } from './services/AuditService';
+export { CaptureService } from './services/CaptureService';
+export { DraftService } from './services/DraftService';
+export { FavoriteService } from './services/FavoriteService';
+export { FlowService } from './services/FlowService';
+export { FolderService } from './services/FolderService';
+export { GranularAclService } from './services/GranularAclService';
+export { GroupService } from './services/GroupService';
+export { InputService } from './services/InputService';
+export { JobService } from './services/JobService';
+export { OauthService } from './services/OauthService';
+export { ResourceService } from './services/ResourceService';
+export { ScheduleService } from './services/ScheduleService';
+export { ScriptService } from './services/ScriptService';
+export { SettingsService } from './services/SettingsService';
+export { UserService } from './services/UserService';
+export { VariableService } from './services/VariableService';
+export { WorkerService } from './services/WorkerService';
+export { WorkspaceService } from './services/WorkspaceService';

package/src/models/AppWithLastVersion.d.ts

@@ -0,0 +1,21 @@
+import type { Policy } from './Policy';
+export type AppWithLastVersion = {
+    id: number;
+    workspace_id: string;
+    path: string;
+    summary: string;
+    versions: Array<number>;
+    created_by: string;
+    created_at: string;
+    value: any;
+    policy: Policy;
+    execution_mode: AppWithLastVersion.execution_mode;
+    extra_perms: Record<string, boolean>;
+};
+export declare namespace AppWithLastVersion {
+    enum execution_mode {
+        VIEWER = "viewer",
+        PUBLISHER = "publisher",
+        ANONYMOUS = "anonymous"
+    }
+}

package/src/models/AppWithLastVersionWDraft.d.ts

@@ -0,0 +1,5 @@
+import type { AppWithLastVersion } from './AppWithLastVersion';
+export type AppWithLastVersionWDraft = (AppWithLastVersion & {
+    draft_only?: boolean;
+    draft?: any;
+});

package/src/models/AuditLog.d.ts

@@ -0,0 +1,32 @@
+export type AuditLog = {
+    id: number;
+    timestamp: string;
+    username: string;
+    operation: AuditLog.operation;
+    action_kind: AuditLog.action_kind;
+    resource?: string;
+    parameters?: any;
+};
+export declare namespace AuditLog {
+    enum operation {
+        JOBS_RUN = "jobs.run",
+        SCRIPTS_CREATE = "scripts.create",
+        SCRIPTS_UPDATE = "scripts.update",
+        USERS_CREATE = "users.create",
+        USERS_DELETE = "users.delete",
+        USERS_SETPASSWORD = "users.setpassword",
+        USERS_UPDATE = "users.update",
+        USERS_LOGIN = "users.login",
+        USERS_TOKEN_CREATE = "users.token.create",
+        USERS_TOKEN_DELETE = "users.token.delete",
+        VARIABLES_CREATE = "variables.create",
+        VARIABLES_DELETE = "variables.delete",
+        VARIABLES_UPDATE = "variables.update"
+    }
+    enum action_kind {
+        CREATED = "Created",
+        UPDATED = "Updated",
+        DELETE = "Delete",
+        EXECUTE = "Execute"
+    }
+}

package/src/models/BranchAll.d.ts

@@ -0,0 +1,10 @@
+import type { FlowModule } from './FlowModule';
+export type BranchAll = {
+    branches: Array<{
+        summary?: string;
+        skip_failure?: boolean;
+        modules: Array<FlowModule>;
+    }>;
+    type: 'branchall';
+    parallel?: boolean;
+};

package/src/models/BranchOne.d.ts

@@ -0,0 +1,10 @@
+import type { FlowModule } from './FlowModule';
+export type BranchOne = {
+    branches: Array<{
+        summary?: string;
+        expr: string;
+        modules: Array<FlowModule>;
+    }>;
+    default: Array<FlowModule>;
+    type: 'branchone';
+};

package/src/models/CompletedJob.d.ts

@@ -0,0 +1,57 @@
+import type { FlowStatus } from './FlowStatus';
+import type { FlowValue } from './FlowValue';
+import type { ScriptArgs } from './ScriptArgs';
+export type CompletedJob = {
+    workspace_id?: string;
+    id: string;
+    parent_job?: string;
+    created_by: string;
+    created_at: string;
+    started_at: string;
+    duration_ms: number;
+    success: boolean;
+    script_path?: string;
+    script_hash?: string;
+    args?: ScriptArgs;
+    result?: any;
+    logs?: string;
+    deleted?: boolean;
+    raw_code?: string;
+    canceled: boolean;
+    canceled_by?: string;
+    canceled_reason?: string;
+    job_kind: CompletedJob.job_kind;
+    schedule_path?: string;
+    /**
+     * The user (u/userfoo) or group (g/groupfoo) whom
+     * the execution of this script will be permissioned_as and by extension its DT_TOKEN.
+     *
+     */
+    permissioned_as: string;
+    flow_status?: FlowStatus;
+    raw_flow?: FlowValue;
+    is_flow_step: boolean;
+    language?: CompletedJob.language;
+    is_skipped: boolean;
+    email: string;
+    visible_to_owner: boolean;
+    mem_peak?: number;
+    tag: string;
+};
+export declare namespace CompletedJob {
+    enum job_kind {
+        SCRIPT = "script",
+        PREVIEW = "preview",
+        DEPENDENCIES = "dependencies",
+        FLOW = "flow",
+        FLOWPREVIEW = "flowpreview",
+        SCRIPT_HUB = "script_hub",
+        IDENTITY = "identity"
+    }
+    enum language {
+        PYTHON3 = "python3",
+        DENO = "deno",
+        GO = "go",
+        BASH = "bash"
+    }
+}

package/src/models/ContextualVariable.d.ts

@@ -0,0 +1,5 @@
+export type ContextualVariable = {
+    name: string;
+    value: string;
+    description: string;
+};

package/src/models/CreateInput.d.ts

@@ -0,0 +1,4 @@
+export type CreateInput = {
+    name: string;
+    args: any;
+};

package/src/models/CreateResource.d.ts

@@ -0,0 +1,6 @@
+export type CreateResource = {
+    path: string;
+    value: any;
+    description?: string;
+    resource_type: string;
+};

package/src/models/CreateVariable.d.ts

@@ -0,0 +1,8 @@
+export type CreateVariable = {
+    path: string;
+    value: string;
+    is_secret: boolean;
+    description: string;
+    account?: number;
+    is_oauth?: boolean;
+};

package/src/models/CreateWorkspace.d.ts

@@ -0,0 +1,5 @@
+export type CreateWorkspace = {
+    id: string;
+    name: string;
+    username: string;
+};

package/src/models/EditResource.d.ts

@@ -0,0 +1,5 @@
+export type EditResource = {
+    path?: string;
+    description?: string;
+    value?: any;
+};

package/src/models/EditResourceType.d.ts

@@ -0,0 +1,4 @@
+export type EditResourceType = {
+    schema?: string;
+    description?: string;
+};

package/src/models/EditSchedule.d.ts

@@ -0,0 +1,6 @@
+import type { ScriptArgs } from './ScriptArgs';
+export type EditSchedule = {
+    schedule: string;
+    timezone: string;
+    args: ScriptArgs;
+};

package/src/models/EditVariable.d.ts

@@ -0,0 +1,6 @@
+export type EditVariable = {
+    path?: string;
+    value?: string;
+    is_secret?: boolean;
+    description?: string;
+};

package/src/models/EditWorkspaceUser.d.ts

@@ -0,0 +1,5 @@
+export type EditWorkspaceUser = {
+    is_admin?: boolean;
+    operator?: boolean;
+    disabled?: boolean;
+};

package/src/models/Flow.d.ts

@@ -0,0 +1,3 @@
+import type { FlowMetadata } from './FlowMetadata';
+import type { OpenFlow } from './OpenFlow';
+export type Flow = (OpenFlow & FlowMetadata);

package/src/models/FlowMetadata.d.ts

@@ -0,0 +1,11 @@
+export type FlowMetadata = {
+    workspace_id?: string;
+    path: string;
+    edited_by: string;
+    edited_at: string;
+    archived: boolean;
+    extra_perms: any;
+    additionalProperties?: boolean;
+    starred?: boolean;
+    draft_only?: boolean;
+};

package/src/models/FlowModule.d.ts

@@ -0,0 +1,18 @@
+import type { FlowModuleValue } from './FlowModuleValue';
+import type { InputTransform } from './InputTransform';
+import type { Retry } from './Retry';
+export type FlowModule = {
+    id: string;
+    value: FlowModuleValue;
+    stop_after_if?: {
+        skip_if_stopped?: boolean;
+        expr: string;
+    };
+    sleep?: InputTransform;
+    summary?: string;
+    suspend?: {
+        required_events?: number;
+        timeout?: number;
+    };
+    retry?: Retry;
+};

package/src/models/FlowModuleValue.d.ts

@@ -0,0 +1,8 @@
+import type { BranchAll } from './BranchAll';
+import type { BranchOne } from './BranchOne';
+import type { ForloopFlow } from './ForloopFlow';
+import type { Identity } from './Identity';
+import type { PathFlow } from './PathFlow';
+import type { PathScript } from './PathScript';
+import type { RawScript } from './RawScript';
+export type FlowModuleValue = (RawScript | PathScript | PathFlow | ForloopFlow | BranchOne | BranchAll | Identity);

package/src/models/FlowPreview.d.ts

@@ -0,0 +1,7 @@
+import type { FlowValue } from './FlowValue';
+import type { ScriptArgs } from './ScriptArgs';
+export type FlowPreview = {
+    value: FlowValue;
+    path?: string;
+    args: ScriptArgs;
+};

package/src/models/FlowStatus.d.ts

@@ -0,0 +1,12 @@
+import type { FlowStatusModule } from './FlowStatusModule';
+export type FlowStatus = {
+    step: number;
+    modules: Array<FlowStatusModule>;
+    failure_module: (FlowStatusModule & {
+        parent_module?: string;
+    });
+    retry?: {
+        fail_count?: number;
+        failed_jobs?: Array<string>;
+    };
+};

package/src/models/FlowStatusModule.d.ts

@@ -0,0 +1,34 @@
+export type FlowStatusModule = {
+    type: FlowStatusModule.type;
+    id?: string;
+    job?: string;
+    count?: number;
+    iterator?: {
+        index?: number;
+        itered?: Array<any>;
+        args?: any;
+    };
+    flow_jobs?: Array<string>;
+    branch_chosen?: {
+        type: FlowStatusModule.type;
+        branch?: number;
+    };
+    branchall?: {
+        branch: number;
+        len: number;
+    };
+    approvers?: Array<{
+        resume_id: number;
+        approver: string;
+    }>;
+};
+export declare namespace FlowStatusModule {
+    enum type {
+        WAITING_FOR_PRIOR_STEPS = "WaitingForPriorSteps",
+        WAITING_FOR_EVENTS = "WaitingForEvents",
+        WAITING_FOR_EXECUTOR = "WaitingForExecutor",
+        IN_PROGRESS = "InProgress",
+        SUCCESS = "Success",
+        FAILURE = "Failure"
+    }
+}

package/src/models/FlowValue.d.ts

@@ -0,0 +1,6 @@
+import type { FlowModule } from './FlowModule';
+export type FlowValue = {
+    modules: Array<FlowModule>;
+    failure_module?: FlowModule;
+    same_worker?: boolean;
+};

package/src/models/Folder.d.ts

@@ -0,0 +1,5 @@
+export type Folder = {
+    name: string;
+    owners: Array<string>;
+    extra_perms: Record<string, boolean>;
+};

package/src/models/ForloopFlow.d.ts

@@ -0,0 +1,9 @@
+import type { FlowModule } from './FlowModule';
+import type { InputTransform } from './InputTransform';
+export type ForloopFlow = {
+    modules: Array<FlowModule>;
+    iterator: InputTransform;
+    skip_failures: boolean;
+    type: 'forloopflow';
+    parallel?: boolean;
+};

package/src/models/GlobalUserInfo.d.ts

@@ -0,0 +1,14 @@
+export type GlobalUserInfo = {
+    email: string;
+    login_type: GlobalUserInfo.login_type;
+    super_admin: boolean;
+    verified: boolean;
+    name?: string;
+    company?: string;
+};
+export declare namespace GlobalUserInfo {
+    enum login_type {
+        PASSWORD = "password",
+        GITHUB = "github"
+    }
+}

package/src/models/Group.d.ts

@@ -0,0 +1,6 @@
+export type Group = {
+    name: string;
+    summary?: string;
+    members?: Array<string>;
+    extra_perms?: Record<string, boolean>;
+};

package/src/models/Identity.d.ts

@@ -0,0 +1,4 @@
+export type Identity = {
+    type: 'identity';
+    flow?: boolean;
+};

package/src/models/Input.d.ts

@@ -0,0 +1,8 @@
+export type Input = {
+    id: string;
+    name: string;
+    args: any;
+    created_by: string;
+    created_at: string;
+    is_public: boolean;
+};

package/src/models/InputTransform.d.ts

@@ -0,0 +1,3 @@
+import type { JavascriptTransform } from './JavascriptTransform';
+import type { StaticTransform } from './StaticTransform';
+export type InputTransform = (StaticTransform | JavascriptTransform);

package/src/models/JavascriptTransform.d.ts

@@ -0,0 +1,4 @@
+export type JavascriptTransform = {
+    expr: string;
+    type: 'javascript';
+};

package/src/models/Job.d.ts

@@ -0,0 +1,11 @@
+import type { CompletedJob } from './CompletedJob';
+import type { QueuedJob } from './QueuedJob';
+export type Job = ((CompletedJob | QueuedJob) & {
+    type?: Job.type;
+});
+export declare namespace Job {
+    enum type {
+        COMPLETED_JOB = "CompletedJob",
+        QUEUED_JOB = "QueuedJob"
+    }
+}

package/src/models/ListableApp.d.ts

@@ -0,0 +1,18 @@
+export type ListableApp = {
+    id: number;
+    workspace_id: string;
+    path: string;
+    summary: string;
+    version: number;
+    extra_perms: Record<string, boolean>;
+    starred?: boolean;
+    edited_at: string;
+    execution_mode: ListableApp.execution_mode;
+};
+export declare namespace ListableApp {
+    enum execution_mode {
+        VIEWER = "viewer",
+        PUBLISHER = "publisher",
+        ANONYMOUS = "anonymous"
+    }
+}

package/src/models/ListableResource.d.ts

@@ -0,0 +1,14 @@
+export type ListableResource = {
+    workspace_id?: string;
+    path: string;
+    description?: string;
+    resource_type: string;
+    value?: any;
+    is_oauth: boolean;
+    extra_perms?: Record<string, boolean>;
+    is_expired?: boolean;
+    refresh_error?: string;
+    is_linked: boolean;
+    is_refreshed: boolean;
+    account?: number;
+};