@leaflow/sdk 0.0.0-dev.415.gb9e4b83 → 0.0.0-dev.418.ge62522e

package/dist/swas/v1/generated/functions.js

@@ -0,0 +1,250 @@
+export const getListPlansUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://swas.leaflow.cloud/api/v1/catalog/plans?${stringifiedParams}`
+        : `https://swas.leaflow.cloud/api/v1/catalog/plans`;
+};
+/**
+ * Lists available plans and prices for the requested region. A plan without a price is not available to buy.
+ * @summary List plans
+ */
+export const listPlans = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPlansUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePurchaseUrl = () => {
+    return `https://swas.leaflow.cloud/api/v1/purchases`;
+};
+/**
+ * Creates a purchase using the current catalog revision and expected price. Reuse the same Idempotency-Key after a timeout. Acceptance is not confirmation of payment or instance delivery.
+ * @summary Create purchase
+ */
+export const createPurchase = async (purchaseCreate, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePurchaseUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers, ...getHeaders(options?.headers) },
+        body: JSON.stringify(purchaseCreate),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPurchaseUrl = (purchaseId) => {
+    return `https://swas.leaflow.cloud/api/v1/purchases/${encodeURIComponent(String(purchaseId))}`;
+};
+/**
+ * Returns purchase, delivery and Billing progress. Payment and instance delivery may finish at different times.
+ * @summary Get purchase
+ */
+export const getPurchase = async (purchaseId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetPurchaseUrl(purchaseId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListInstancesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://swas.leaflow.cloud/api/v1/instances?${stringifiedParams}`
+        : `https://swas.leaflow.cloud/api/v1/instances`;
+};
+/**
+ * Lists the current project's instances in the requested region. Pagination uses page and page_size; total_count is returned when known.
+ * @summary List instances
+ */
+export const listInstances = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListInstancesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetInstanceUrl = (instanceId) => {
+    return `https://swas.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}`;
+};
+/**
+ * Returns an instance and its most recently observed status.
+ * @summary Get instance
+ */
+export const getInstance = async (instanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetInstanceUrl(instanceId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getStartInstanceUrl = (instanceId) => {
+    return `https://swas.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}:start`;
+};
+/**
+ * Starts an existing instance. Returns an operation to poll; acceptance is not completion.
+ * @summary Start instance
+ */
+export const startInstance = async (instanceId, startInstanceBody, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getStartInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers, ...getHeaders(options?.headers) },
+        body: JSON.stringify(startInstanceBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetInstanceOperationUrl = (instanceId, operationId) => {
+    return `https://swas.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/operations/${encodeURIComponent(String(operationId))}`;
+};
+/**
+ * Returns management progress for the specified instance. Unknown progress is not confirmation of success; do not repeat an operation solely because its outcome is unknown.
+ * @summary Get instance operation
+ */
+export const getInstanceOperation = async (instanceId, operationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetInstanceOperationUrl(instanceId, operationId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getStopInstanceUrl = (instanceId) => {
+    return `https://swas.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}:stop`;
+};
+/**
+ * Stops an existing instance. Returns an operation to poll; acceptance is not completion.
+ * @summary Stop instance
+ */
+export const stopInstance = async (instanceId, stopInstanceBody, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getStopInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers, ...getHeaders(options?.headers) },
+        body: JSON.stringify(stopInstanceBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetCancellationRefundProgressUrl = (instanceId, cancellationId) => {
+    return `https://swas.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}/cancellations/${encodeURIComponent(String(cancellationId))}/refund-progress`;
+};
+/**
+ * Returns cancellation and refund progress for the specified instance. Unknown refund amounts and currencies are null. A completed cancellation does not confirm that money has been returned.
+ * @summary Get cancellation refund progress
+ */
+export const getCancellationRefundProgress = async (instanceId, cancellationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetCancellationRefundProgressUrl(instanceId, cancellationId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return {
+        data,
+        status: res.status,
+        headers: res.headers,
+    };
+};
+export const getRebootInstanceUrl = (instanceId) => {
+    return `https://swas.leaflow.cloud/api/v1/instances/${encodeURIComponent(String(instanceId))}:reboot`;
+};
+/**
+ * Reboots an existing instance. Returns an operation to poll; an unchanged Running status does not confirm completion.
+ * @summary Reboot instance
+ */
+export const rebootInstance = async (instanceId, rebootInstanceBody, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRebootInstanceUrl(instanceId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers, ...getHeaders(options?.headers) },
+        body: JSON.stringify(rebootInstanceBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};

package/dist/swas/v1/generated/models.d.ts

@@ -0,0 +1,384 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow SWAS API
+ * Manage SWAS purchases and instances in the current project. Use an IAM scoped token for every request. Amounts are decimal strings in the stated currency; timestamps are UTC RFC 3339. Accepted requests may still be in progress. Read purchase, operation and refund progress separately.
+ * OpenAPI spec version: 1.0.0
+ */
+/**
+ * A decimal string, in the currency stated alongside it.
+ *
+ * **The currency is not part of this type.** It is carried by a `currency` field next to the
+ * amount, or by the account the amount belongs to. Reading an amount without that field is
+ * reading a number with no unit.
+ *
+ * It is a string rather than a JSON number because a JSON number is a float in most parsers,
+ * and a float loses precision on the first arithmetic. Nothing on this platform puts an amount
+ * through a float.
+ */
+export type Money = string;
+/**
+ * A non-negative decimal amount with at most 15 integer digits and 10 fractional digits.
+ */
+export type DecimalAmount = Money & string;
+export interface ExpectedQuote {
+    currency: "USD";
+    amount: DecimalAmount;
+}
+export interface PurchaseCreate {
+    /**
+     * @minimum 1
+     * @maximum 9007199254740991
+     */
+    catalog_revision: number;
+    /**
+     * @minLength 1
+     * @maxLength 256
+     */
+    provider_plan_id: string;
+    /** @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ */
+    billing_price_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 256
+     */
+    image_id: string;
+    quantity: 1;
+    expected_quote: ExpectedQuote;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    region_id: string;
+}
+export type PurchaseState = (typeof PurchaseState)[keyof typeof PurchaseState];
+export declare const PurchaseState: {
+    readonly submitted: "submitted";
+    readonly checkout_create_reserved: "checkout_create_reserved";
+    readonly checkout_unknown: "checkout_unknown";
+    readonly checkout_open: "checkout_open";
+    readonly order_ready: "order_ready";
+    readonly accept_unknown: "accept_unknown";
+    readonly accepted: "accepted";
+    readonly create_unknown: "create_unknown";
+    readonly awaiting_delivery: "awaiting_delivery";
+    readonly delivered: "delivered";
+    readonly settle_unknown: "settle_unknown";
+    readonly completed: "completed";
+    readonly rejected: "rejected";
+    readonly provider_rejected: "provider_rejected";
+};
+/**
+ * Durable purchase progress. delivered and billing_settled describe different facts. Acceptance is not cloud delivery or checkout completion.
+ */
+export interface Purchase {
+    /** @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ */
+    id: string;
+    state: PurchaseState;
+    /** @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ */
+    checkout_session_id: string;
+    delivered: boolean;
+    billing_settled: boolean;
+}
+export type PricePeriodMonths = (typeof PricePeriodMonths)[keyof typeof PricePeriodMonths] | null;
+export declare const PricePeriodMonths: {
+    readonly NUMBER_1: 1;
+    readonly NUMBER_3: 3;
+    readonly NUMBER_6: 6;
+    readonly NUMBER_12: 12;
+    readonly NUMBER_24: 24;
+    readonly NUMBER_36: 36;
+};
+export interface Price {
+    /** @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ */
+    billing_plan_id: string;
+    /** @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ */
+    billing_price_id: string;
+    currency: "USD";
+    amount: DecimalAmount;
+    period_months: PricePeriodMonths;
+}
+export interface Plan {
+    provider_plan_id: string;
+    region_id: string;
+    name: string;
+    /** @minimum 1 */
+    catalog_revision: number;
+    buyable: boolean;
+    price: Price | null;
+    /**
+     * @minItems 1
+     * @maxItems 256
+     */
+    image_ids: string[];
+    /** @minimum 1 */
+    cpu: number;
+    /** @minimum 1 */
+    memory_mb: number;
+    /** @minimum 1 */
+    disk_gb: number;
+}
+/**
+ * Bounded catalog snapshot for one requested region. Incomplete or unavailable price information is not a purchasable offer.
+ */
+export interface Catalog {
+    items: Plan[];
+    /** UTC RFC 3339 timestamp. */
+    source_observed_at: string;
+    complete: boolean;
+}
+/**
+ * What a given `code` carries alongside the message. The keys depend on the code,
+ * and a client that does not recognise one ignores it.
+ */
+export type ErrorMeta = {
+    [key: string]: unknown;
+};
+export interface Error {
+    code?: string;
+    message: string;
+    /**
+     * What a given `code` carries alongside the message. The keys depend on the code,
+     * and a client that does not recognise one ignores it.
+     */
+    meta?: ErrorMeta;
+    status: number;
+}
+export type InstancePricePeriodMonths = (typeof InstancePricePeriodMonths)[keyof typeof InstancePricePeriodMonths];
+export declare const InstancePricePeriodMonths: {
+    readonly NUMBER_1: 1;
+    readonly NUMBER_3: 3;
+    readonly NUMBER_6: 6;
+    readonly NUMBER_12: 12;
+    readonly NUMBER_24: 24;
+    readonly NUMBER_36: 36;
+};
+export interface InstancePrice {
+    currency: "USD";
+    amount: DecimalAmount;
+    period_months: InstancePricePeriodMonths;
+}
+export declare const InstanceCapabilitiesValue: {
+    readonly manage: false;
+    readonly customer_refund: false;
+    readonly supplier_refund: false;
+    readonly release: false;
+};
+export type InstanceCapabilities = typeof InstanceCapabilitiesValue;
+export type InstanceStatus = (typeof InstanceStatus)[keyof typeof InstanceStatus];
+export declare const InstanceStatus: {
+    readonly Pending: "Pending";
+    readonly Starting: "Starting";
+    readonly Running: "Running";
+    readonly Stopping: "Stopping";
+    readonly Stopped: "Stopped";
+    readonly Resetting: "Resetting";
+    readonly Upgrading: "Upgrading";
+    readonly Disabled: "Disabled";
+    readonly Unknown: "Unknown";
+};
+export type InstanceBusinessStatus = (typeof InstanceBusinessStatus)[keyof typeof InstanceBusinessStatus];
+export declare const InstanceBusinessStatus: {
+    readonly Normal: "Normal";
+    readonly Expired: "Expired";
+    readonly Overdue: "Overdue";
+    readonly Unknown: "Unknown";
+};
+export type InstanceObservation = (typeof InstanceObservation)[keyof typeof InstanceObservation];
+export declare const InstanceObservation: {
+    readonly present: "present";
+    readonly missing: "missing";
+};
+export interface Instance {
+    id: string;
+    purchase_id: string;
+    project_id: string;
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    region_id: string;
+    /** @maxLength 128 */
+    provider_plan_id: string;
+    /** @maxLength 128 */
+    image_id: string;
+    status: InstanceStatus;
+    business_status: InstanceBusinessStatus;
+    observation: InstanceObservation;
+    created_at: string | null;
+    expires_at: string | null;
+    original_price: InstancePrice;
+    /** UTC RFC 3339 timestamp. */
+    source_observed_at: string;
+    /**
+     * @minimum 1
+     * @maximum 9007199254740991
+     */
+    sync_revision: number;
+    capabilities: InstanceCapabilities;
+}
+/**
+ * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
+ */
+export interface OffsetPagination {
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+    /** @minimum 0 */
+    total_count?: number;
+}
+export type InstancePagination = OffsetPagination;
+export interface InstanceList {
+    /** @maxItems 200 */
+    items: Instance[];
+    pagination: OffsetPagination;
+}
+export interface StartInstance {
+    [key: string]: unknown;
+}
+export type ManagementOperationAction = (typeof ManagementOperationAction)[keyof typeof ManagementOperationAction];
+export declare const ManagementOperationAction: {
+    readonly start: "start";
+    readonly stop: "stop";
+    readonly reboot: "reboot";
+};
+export type ManagementOperationState = (typeof ManagementOperationState)[keyof typeof ManagementOperationState];
+export declare const ManagementOperationState: {
+    readonly queued: "queued";
+    readonly dispatch_unknown: "dispatch_unknown";
+    readonly provider_ack: "provider_ack";
+    readonly completed: "completed";
+};
+export type ManagementOperationLastObservedStatus = (typeof ManagementOperationLastObservedStatus)[keyof typeof ManagementOperationLastObservedStatus];
+export declare const ManagementOperationLastObservedStatus: {
+    readonly Stopped: "Stopped";
+    readonly Running: "Running";
+    readonly Starting: "Starting";
+};
+/**
+ * Observed reboot progress. running_observed_at is null until a later Running observation is available.
+ */
+export interface RebootCycle {
+    /** UTC RFC 3339 timestamp. */
+    starting_observed_at: string;
+    running_observed_at: string | null;
+}
+/**
+ * Read state to follow the operation. For a reboot, reboot_cycle records a Starting observation followed by a later Running observation. A missing cycle or null running time does not confirm completion.
+ */
+export interface ManagementOperation {
+    id: string;
+    purchase_id: string;
+    action: ManagementOperationAction;
+    state: ManagementOperationState;
+    last_observed_status: ManagementOperationLastObservedStatus;
+    /** UTC RFC 3339 timestamp. */
+    created_at: string;
+    /** UTC RFC 3339 timestamp. */
+    updated_at: string;
+    reboot_cycle?: RebootCycle;
+}
+export interface StopInstance {
+    [key: string]: unknown;
+}
+export interface CustomerRefundProgress {
+    state: "unknown";
+    reason: "billing_refund_reader_unavailable";
+    /** @nullable */
+    amount: null;
+    /** @nullable */
+    currency: null;
+}
+export declare const SupplierRefundProgressValue: {
+    readonly state: "not_observed";
+    readonly reason: "supplier_refund_not_queried";
+};
+export type SupplierRefundProgress = typeof SupplierRefundProgressValue;
+export type RefundProgressCancellationState = (typeof RefundProgressCancellationState)[keyof typeof RefundProgressCancellationState];
+export declare const RefundProgressCancellationState: {
+    readonly requested: "requested";
+    readonly scheduled: "scheduled";
+    readonly releasing: "releasing";
+    readonly completed: "completed";
+    readonly canceled: "canceled";
+    readonly failed: "failed";
+};
+/**
+ * Cancellation and refund progress are independent. Unknown money amounts and currencies are null; cancellation completion does not confirm cash settlement.
+ */
+export interface RefundProgress {
+    purchase_id: string;
+    cancellation_id: string;
+    cancellation_state: RefundProgressCancellationState;
+    customer_refund: CustomerRefundProgress;
+    supplier_refund: SupplierRefundProgress;
+    /** UTC RFC 3339 timestamp. */
+    observed_at: string;
+}
+export interface RebootInstance {
+    [key: string]: unknown;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+export type ListPlansParams = {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    region_id: string;
+};
+export type CreatePurchaseHeaders = {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    "Idempotency-Key": string;
+};
+export type ListInstancesParams = {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    region_id: string;
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type StartInstanceHeaders = {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    "Idempotency-Key": string;
+};
+export type StopInstanceHeaders = {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    "Idempotency-Key": string;
+};
+export type RebootInstanceHeaders = {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    "Idempotency-Key": string;
+};