@tarkahq/sdk 0.0.0-stage → 0.3.0

package/dist/esm/resources/provisioning.js

@@ -0,0 +1,531 @@
+import { requireText, required } from "../errors.js";
+import { OrganizationSandboxes } from "./sandboxes.js";
+/** The authenticated account and its initial organization. Access through `client.user`. */
+export class Users {
+    #rpc;
+    constructor(rpc) {
+        this.#rpc = rpc;
+    }
+    /**
+     * Retrieve the current user, organization memberships, and default organization.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async get(options) {
+        return this.#rpc.getCurrentUser(options);
+    }
+    /**
+     * Initialize the authenticated account and its first organization.
+     *
+     * @param input - Optional organization display name; when omitted, the server derives a name.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async bootstrap(input = {}, options) {
+        return this.#rpc.bootstrapCurrentUser(input, options);
+    }
+}
+/** Organizations accessible to the authenticated account. Access through `client.organizations`. */
+export class Organizations {
+    #rpc;
+    constructor(rpc) {
+        this.#rpc = rpc;
+    }
+    /**
+     * Return the current user's organizations as an array.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(options) {
+        return (await this.#rpc.getCurrentUser(options)).orgs;
+    }
+    /**
+     * Retrieve an organization record.
+     *
+     * @param id - Organization identifier.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async get(id, options) {
+        requireText(id, "organization id");
+        return this.#rpc.getOrg({ orgId: id }, options);
+    }
+    /**
+     * Create an organization with the authenticated caller as its owner.
+     *
+     * @param input - Display name and optional globally unique slug. The server allocates an omitted slug.
+     * @returns The organization record; use `client.org(result.id)` to access its resources.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        requireText(input?.name, "name");
+        return this.#rpc.createOrg(input, options);
+    }
+}
+/** Memberships of the bound organization. Access through `client.org(orgId).members`. */
+export class Members {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * Return the organization's members as an array.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(options) {
+        return (await this.#rpc.listOrgMembers({ orgId: this.orgId }, options))
+            .members;
+    }
+}
+/** Product access requests for the bound organization. Access through `org.accessRequests`. */
+export class AccessRequests {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * List recent product access requests, newest first.
+     *
+     * @param filter - Optional product and result limit; the server defaults to 25 and caps the limit at 100.
+     * @returns An array from one server response; the SDK does not fetch additional pages.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(filter = {}, options) {
+        return (await this.#rpc.listProductAccessRequests({ ...filter, orgId: this.orgId }, options)).requests;
+    }
+    /**
+     * Submit a product access request for this organization.
+     *
+     * @param input - Product, use case, and optional contact/company details. Omitted contact email uses the authenticated account.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        requireText(input?.product, "product");
+        return this.#rpc.requestProductAccess({ ...input, orgId: this.orgId }, options);
+    }
+}
+/** API keys for the bound organization. Access through `org.apiKeys`. */
+export class ApiKeys {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * List API key metadata. Previously issued plaintext secrets are not returned.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(options) {
+        return (await this.#rpc.listApiKeys({ orgId: this.orgId }, options))
+            .apiKeys;
+    }
+    /**
+     * Create an API key and return its metadata with a one-time `secret`.
+     *
+     * @param input - Optional label, product scopes, and allowed model aliases. Omitted scopes use the server's inference default.
+     * @returns The key record plus `secret`; store the secret at creation because it cannot be retrieved later.
+     * @example
+     * const key = await org.apiKeys.create({ label: "worker", scopes: ["inference"] });
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input = {}, options) {
+        const response = await this.#rpc.createApiKey({ ...input, orgId: this.orgId }, options);
+        return {
+            ...required(response.apiKey, "apiKey"),
+            secret: response.plaintextKey,
+        };
+    }
+    /**
+     * Revoke an API key and return its updated metadata.
+     *
+     * @param id - API key identifier, not its secret.
+     * @param input - Optional human-readable revocation reason.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async revoke(id, input = {}, options) {
+        requireText(id, "API key id");
+        return required((await this.#rpc.revokeApiKey({ orgId: this.orgId, apiKeyId: id, revokedReason: input.reason }, options)).apiKey, "apiKey");
+    }
+}
+/** Inference limits and model policy for the bound organization. Access through `org.quotas`. */
+export class Quotas {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * Retrieve the organization's effective inference quota policy.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async get(options) {
+        return this.#rpc.getQuotaPolicy({ orgId: this.orgId }, options);
+    }
+    /**
+     * Replace the organization's quota policy.
+     *
+     * Omitted optional limits become unlimited. This is a replacement, so include all limits you intend to retain.
+     * @param input - Complete desired policy. Supply `allowedModelAliases` when `allowAllModels` is false; 64-bit budgets use bigint.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async update(input, options) {
+        return this.#rpc.updateQuotaPolicy({ ...input, orgId: this.orgId }, options);
+    }
+}
+/** Inference usage for the bound organization. Access through `org.usage`. */
+export class Usage {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * List usage events as an array.
+     *
+     * @param filter - Optional result limit; omitted values use the server default.
+     * @returns One server response without automatic pagination; 64-bit counters and IDs remain bigint.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(filter = {}, options) {
+        return (await this.#rpc.listUsageEvents({ ...filter, orgId: this.orgId }, options)).usageEvents;
+    }
+    /**
+     * Retrieve the organization's aggregate usage counters.
+     *
+     * @returns A usage summary with lossless bigint counters.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async summary(options) {
+        return this.#rpc.getUsageSummary({ orgId: this.orgId }, options);
+    }
+}
+/** Observed and desired state of managed compute. Access through `org.compute.resources`. */
+export class ComputeResources {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * List provisioned compute resources as an array.
+     *
+     * @param filter - Optional resource type filter.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(filter = {}, options) {
+        return (await this.#rpc.listProvisionedResources({ ...filter, orgId: this.orgId }, options)).resources;
+    }
+    /**
+     * Retrieve the current record for a provisioned compute resource.
+     *
+     * @param id - Resource identifier returned by a compute creation method.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async get(id, options) {
+        requireText(id, "resource id");
+        return this.#rpc.getProvisionedResource({ orgId: this.orgId, resourceId: id }, options);
+    }
+}
+/** Managed inference service creation. Access through `org.compute.inferenceServices`. */
+export class InferenceServices {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * Request a managed inference service and return its resource record.
+     *
+     * @param input - DNS-label name, model alias, and optional capacity/specification fields.
+     * @returns Desired and observed resource state. Creation does not poll for readiness; inspect `org.compute.resources.get(id)`.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        return this.#rpc.createInferenceService({ ...input, orgId: this.orgId }, options);
+    }
+}
+/** Managed agent host creation. Access through `org.compute.agentHosts`. */
+export class AgentHosts {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * Request an agent host and return its resource record.
+     *
+     * @param input - DNS-label name, container image, and optional service/capacity settings. Extension `spec` must not contain secrets.
+     * @returns Desired and observed resource state, without readiness polling.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        return this.#rpc.createAgentHost({ ...input, orgId: this.orgId }, options);
+    }
+}
+/** Finite-duration container jobs. Access through `org.compute.jobs`. */
+export class Jobs {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * Request a container job and return its resource record.
+     *
+     * @param input - DNS-label name, container image, optional argv `command`, and server execution limit in `timeoutSeconds`.
+     * @returns Desired and observed resource state, without waiting for the job to finish. Commands are passed without shell expansion.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        return this.#rpc.createJob({ ...input, orgId: this.orgId }, options);
+    }
+}
+/** Managed compute for the bound organization. Access through `org.compute`. */
+export class Compute {
+    /** List and inspect all provisioned compute resource types. */
+    resources;
+    /** Create managed inference services. */
+    inferenceServices;
+    /** Create managed agent hosts. */
+    agentHosts;
+    /** Create container jobs. */
+    jobs;
+    constructor(rpc, orgId) {
+        this.resources = new ComputeResources(rpc, orgId);
+        this.inferenceServices = new InferenceServices(rpc, orgId);
+        this.agentHosts = new AgentHosts(rpc, orgId);
+        this.jobs = new Jobs(rpc, orgId);
+    }
+}
+/** Storage buckets for the bound organization. Access through `org.storage.buckets`. */
+export class StorageBuckets {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * List the organization's bucket records as an array.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(options) {
+        return (await this.#rpc.listStorageBuckets({ orgId: this.orgId }, options))
+            .buckets;
+    }
+    /**
+     * Create a storage bucket and return its record.
+     *
+     * @param input - Requested bucket name.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        requireText(input?.name, "name");
+        return this.#rpc.createStorageBucket({ ...input, orgId: this.orgId }, options);
+    }
+    /**
+     * Request deletion of a storage bucket.
+     *
+     * @param id - Bucket identifier, not its display name.
+     * @returns Resolves without a value after acknowledgement.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async delete(id, options) {
+        requireText(id, "bucket id");
+        await this.#rpc.deleteStorageBucket({ orgId: this.orgId, bucketId: id }, options);
+    }
+}
+/** Credentials scoped to one organization and bucket. Obtain through `org.storage.credentials(bucketId)`. */
+export class StorageCredentials {
+    orgId;
+    bucketId;
+    #rpc;
+    constructor(rpc, orgId, bucketId) {
+        this.orgId = orgId;
+        this.bucketId = bucketId;
+        this.#rpc = rpc;
+        requireText(bucketId, "bucket id");
+    }
+    /**
+     * List credential metadata for this bucket; plaintext secrets are not returned.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(options) {
+        return (await this.#rpc.listStorageCredentials({ orgId: this.orgId, bucketId: this.bucketId }, options)).credentials;
+    }
+    /**
+     * Create a bucket credential with one-time access credentials.
+     *
+     * @param input - Optional display label for the credential.
+     * @returns Credential metadata plus `accessKeyId`, `secretAccessKey`, `endpoint`, and `region`. Store the secret at creation.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input = {}, options) {
+        const response = await this.#rpc.createStorageCredential({ ...input, orgId: this.orgId, bucketId: this.bucketId }, options);
+        return {
+            ...required(response.credential, "credential"),
+            accessKeyId: response.accessKeyId,
+            secretAccessKey: response.secretAccessKey,
+            endpoint: response.endpoint,
+            region: response.region,
+        };
+    }
+    /**
+     * Revoke a bucket credential and return its updated metadata.
+     *
+     * @param id - Credential identifier from its record, not the access key or secret.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async revoke(id, options) {
+        requireText(id, "credential id");
+        return this.#rpc.revokeStorageCredential({ orgId: this.orgId, bucketId: this.bucketId, credentialId: id }, options);
+    }
+}
+/** Storage resources for the bound organization. Access through `org.storage`. */
+export class Storage {
+    orgId;
+    #rpc;
+    /** Create, list, and delete storage buckets. */
+    buckets;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+        this.buckets = new StorageBuckets(rpc, orgId);
+    }
+    /**
+     * Bind credential operations to a bucket without making a network request.
+     *
+     * @param bucketId - Bucket identifier returned by `buckets.create()` or `buckets.list()`.
+     * @example
+     * const credentials = org.storage.credentials(bucket.id);
+     * const key = await credentials.create({ label: "worker" });
+     */
+    credentials(bucketId) {
+        return new StorageCredentials(this.#rpc, this.orgId, bucketId);
+    }
+}
+/** Hosted Git repositories for the bound organization. Access through `org.repositories`. */
+export class GitRepositories {
+    orgId;
+    #rpc;
+    constructor(rpc, orgId) {
+        this.orgId = orgId;
+        this.#rpc = rpc;
+    }
+    /**
+     * List hosted Git repository records as an array.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async list(options) {
+        return (await this.#rpc.listGitRepositories({ orgId: this.orgId }, options))
+            .repositories;
+    }
+    /**
+     * Create a hosted Git repository and return its record.
+     *
+     * @param input - Repository name and optional description, visibility, and initialization settings.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async create(input, options) {
+        requireText(input?.name, "name");
+        return this.#rpc.createGitRepository({ ...input, orgId: this.orgId }, options);
+    }
+    /**
+     * Request deletion of a hosted Git repository.
+     *
+     * @param id - Repository identifier.
+     * @returns Resolves without a value after acknowledgement.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async delete(id, options) {
+        requireText(id, "repository id");
+        await this.#rpc.deleteGitRepository({ orgId: this.orgId, repositoryId: id }, options);
+    }
+}
+/** Hosted Git access for the authenticated account. Access through `client.git`. */
+export class Git {
+    #rpc;
+    constructor(rpc) {
+        this.#rpc = rpc;
+    }
+    /**
+     * Ensure the account has a hosted Git identity and return its current access state.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async ensureAccess(options) {
+        return this.#rpc.ensureHostedGitAccess(options);
+    }
+}
+/** Organization context created by `client.org(id)`. Construction makes no network request; nested calls retain this organization ID. */
+export class OrganizationScope {
+    id;
+    #rpc;
+    /** Organization memberships. */
+    members;
+    /** Product entitlement requests. */
+    accessRequests;
+    /** API key creation, metadata, and revocation. */
+    apiKeys;
+    /** Inference quota and model policy. */
+    quotas;
+    /** Usage events and aggregate counters. */
+    usage;
+    /** Managed inference services, agent hosts, and jobs. */
+    compute;
+    /** Storage buckets and bucket-scoped credentials. */
+    storage;
+    /** Hosted Git repositories. */
+    repositories;
+    /** Sandbox lifecycle, reusable templates, and code execution. */
+    sandboxes;
+    constructor(rpc, sandboxRpc, 
+    /** Organization identifier automatically included in this scope's requests. */
+    id) {
+        this.id = id;
+        this.#rpc = rpc;
+        requireText(id, "organization id");
+        this.members = new Members(rpc, id);
+        this.accessRequests = new AccessRequests(rpc, id);
+        this.apiKeys = new ApiKeys(rpc, id);
+        this.quotas = new Quotas(rpc, id);
+        this.usage = new Usage(rpc, id);
+        this.compute = new Compute(rpc, id);
+        this.storage = new Storage(rpc, id);
+        this.repositories = new GitRepositories(rpc, id);
+        this.sandboxes = new OrganizationSandboxes(sandboxRpc, id);
+    }
+    /**
+     * Fetch this organization's record.
+     *
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async get(options) {
+        return this.#rpc.getOrg({ orgId: this.id }, options);
+    }
+    /**
+     * Update this organization's display name and return its record.
+     *
+     * @param input - New non-empty display name; the immutable slug is unchanged.
+     * @param options - Per-call timeout in milliseconds, cancellation signal, and metadata.
+     */
+    async update(input, options) {
+        requireText(input?.name, "name");
+        return this.#rpc.updateOrg({ orgId: this.id, name: input.name }, options);
+    }
+}