@scaleway/sdk 0.0.2-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1126 @@
+declare type Region = 'fr-par' | 'nl-ams' | 'pl-waw' | string;
+declare type Zone = 'fr-par-1' | 'fr-par-2' | 'fr-par-3' | 'nl-ams-1' | 'pl-waw-1' | string;
+
+/**
+ * Holds access key and secret key.
+ *
+ * @public
+ */
+interface AuthenticationSecrets {
+    /**
+     * You need an access key and a secret key to connect to Scaleway API.
+     * Generate your token at the following address: {@link https://console.scaleway.com/project/credentials}.
+     */
+    accessKey: string;
+    /**
+     * The secret key is the value that can be used to authenticate against the API (the value used in X-Auth-Token HTTP-header).
+     * The secret key MUST remain secret and not given to anyone or published online.
+     */
+    secretKey: string;
+}
+/**
+ * Holds default values of a Scaleway profile.
+ *
+ * @public
+ */
+interface DefaultValues {
+    /**
+     * APIURL overrides the API URL of the Scaleway API to the given URL.
+     * Change that if you want to direct requests to a different endpoint.
+     *
+     * @defaultValue `https://api.scaleway.com`
+     */
+    apiURL: string;
+    /**
+     * Your organization ID is the identifier of your account inside Scaleway infrastructure.
+     */
+    defaultOrganizationId?: string;
+    /**
+     * Your project ID is the identifier of the project your resources are attached to.
+     */
+    defaultProjectId?: string;
+    /**
+     * A region is represented as a geographical area such as France (Paris) or the Netherlands (Amsterdam).
+     * It can contain multiple availability zones.
+     *
+     * Examples: fr-par, nl-ams.
+     */
+    defaultRegion?: Region;
+    /**
+     * A region can be split into many availability zones (AZ).
+     * Latency between multiple AZ of the same region are low as they have a common network layer.
+     *
+     * Examples: fr-par-1, nl-ams-1
+     */
+    defaultZone?: Zone;
+}
+/**
+ * Holds values of a Scaleway profile.
+ *
+ * @public
+ */
+declare type Profile = Partial<DefaultValues & AuthenticationSecrets>;
+
+interface Interceptor<T> {
+    (instance: Readonly<T>): T | Promise<T>;
+}
+
+/** Request Interceptor. */
+declare type RequestInterceptor = Interceptor<Request>;
+
+/** Response Interceptor. */
+declare type ResponseInterceptor = Interceptor<Response>;
+
+/**
+ * Settings hold the values of all client options.
+ *
+ * @public
+ */
+interface Settings extends DefaultValues {
+    /**
+     * The default number of results when requesting a paginated resource.
+     */
+    defaultPageSize?: number;
+    /**
+     * HTTP Client doing the requests.
+     */
+    httpClient: typeof fetch;
+    /**
+     * The Request interceptors.
+     */
+    requestInterceptors: RequestInterceptor[];
+    /**
+     * The Response interceptors.
+     */
+    responseInterceptors: ResponseInterceptor[];
+    /**
+     * The User-Agent sent with each request.
+     *
+     * @defaultValue scaleway-sdk-js/version
+     */
+    userAgent: string;
+}
+
+/**
+ * A factory to build {@link Settings}.
+ *
+ * @public
+ */
+declare type ClientConfig = (obj: Settings) => Settings;
+/**
+ * Instanciates the SDK from a configuration {@link Profile}.
+ *
+ * @param profile - The profile
+ * @returns A factory {@link ClientConfig}
+ *
+ * @public
+ */
+declare const withProfile: (profile: Readonly<Profile>) => (settings: Readonly<Settings>) => Settings;
+
+/** Scaleway Request. */
+declare type ScwRequest = {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    headers?: Record<string, string>;
+    body?: string;
+    urlParams?: URLSearchParams;
+};
+/**
+ * A factory to unmarshal a response.
+ *
+ * @param obj - The input object.
+ * @returns The output object
+ */
+declare type ResponseUnmarshaller<T> = (obj: unknown) => T;
+interface PaginatedResponse {
+    totalCount: number;
+}
+
+declare type Fetcher = <T>(request: Readonly<ScwRequest>, unwrapper?: ResponseUnmarshaller<T>) => Promise<T>;
+
+/**
+ * Scaleway client.
+ */
+declare type ScwClient = {
+    fetch: Fetcher;
+    settings: Settings;
+};
+/**
+ * Creates a Scaleway client with advanced options.
+ * You can either use existing factories
+ * (like `withProfile`, `withUserAgentSuffix`, etc)
+ * or write your own using the interface `ClientConfig`.
+ *
+ * @example
+ * Creates a client with factories:
+ * ```
+ * createAdvancedScwClient(
+ *   (obj: Settings) => ({
+ *     ...obj,
+ *     defaultPageSize: 100 ,
+ *     httpClient: myFetchWrapper,
+ *   }),
+ *   withUserAgentSuffix('bot-name/1.0'),
+ * )
+ * ```
+ *
+ * @throws Error
+ * Thrown if the setup fails.
+ *
+ * @public
+ */
+declare const createAdvancedScwClient: (...configs: ClientConfig[]) => ScwClient;
+/**
+ * Creates a Scaleway client with a profile (recommended).
+ *
+ * @example
+ * Creates a client with hard coded values:
+ * ```
+ * createScwClient({
+ *   accessKey: 'SCWXXXXXXXXXXXXXXXXX',
+ *   secretKey: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+ *   defaultProjectId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+ *   defaultRegion: 'fr',
+ *   defaultZone: 'fr-par-1',
+ * })
+ * ```
+ *
+ * @example
+ * Creates a client by loading values from the environment or the config file:
+ * ```
+ * import { loadProfileFromConfigurationFile } from '@scaleway/configuration-loader'
+ *
+ * createScwClient({
+ *   ...await loadProfileFromConfigurationFile(),
+ *   defaultZone: 'fr-par-3',
+ * })
+ * ```
+ *
+ * @throws Error
+ * Thrown if the setup fails.
+ *
+ * @public
+ */
+declare const createScwClient: (profile?: Profile) => ScwClient;
+
+declare enum LevelResolver {
+    silent = 0,
+    error = 1,
+    warn = 2,
+    info = 3,
+    debug = 4
+}
+declare type LogLevel = keyof typeof LevelResolver;
+
+/**
+ * Logger.
+ *
+ * @public
+ */
+interface Logger {
+    readonly logLevel: LogLevel;
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+
+/**
+ * Sets a logger to be used within the SDK.
+ *
+ * @param logger - The Logger instance
+ *
+ * @public
+ */
+declare const setLogger: (logger: Readonly<Logger>) => void;
+/**
+ * Sets the logger to console logger with given logLevel.
+ *
+ * @param logLevel - The Log level name
+ *
+ * @public
+ */
+declare const enableConsoleLogger: (logLevel?: LogLevel) => void;
+
+interface TokenAccessor {
+    (): Promise<string>;
+}
+/**
+ * Authenticates with a session token.
+ *
+ * @param getToken - The token accessor
+ * @returns The request interceptor
+ *
+ * @internal
+ */
+declare const authenticateWithSessionToken: (getToken: TokenAccessor) => RequestInterceptor;
+
+/**
+ * Unmarshals input to a record with camilized keys and instanciated Date.
+ *
+ * @param obj - The input
+ * @param ignoreKeys - The keys which should be not be transformed
+ * @param dateKeys - The keys which should be transformed to Date
+ * @returns The record
+ *
+ * @throws TypeError
+ * Thrown if the input isn't {@link JSONObject}.
+ *
+ * @internal
+ */
+declare const unmarshalAnyRes: <T>(obj: unknown, ignoreKeys?: string[], dateKeys?: string[] | undefined) => T;
+
+/**
+ * Abstract class to instanciate API from a {@link ScwClient}
+ * @internal
+ */
+declare abstract class API {
+    protected client: ScwClient;
+    constructor(client: ScwClient);
+}
+
+declare type RegionFetcher<T, R> = (request: R) => Promise<T[]>;
+/**
+ * Executes a request for several regions at once.
+ *
+ * @param regions - The regions
+ * @param fetcher - The fetcher
+ * @param request - The request
+ * @returns The resolved promise
+ *
+ * @internal
+ */
+declare const forRegions: <T, R extends {
+    region?: string | undefined;
+}>(regions: Region[], fetcher: RegionFetcher<T, R>, request: R) => Promise<T[]>;
+
+declare const internals_authenticateWithSessionToken: typeof authenticateWithSessionToken;
+declare const internals_unmarshalAnyRes: typeof unmarshalAnyRes;
+type internals_API = API;
+declare const internals_API: typeof API;
+declare const internals_forRegions: typeof forRegions;
+declare namespace internals {
+  export {
+    internals_authenticateWithSessionToken as authenticateWithSessionToken,
+    internals_unmarshalAnyRes as unmarshalAnyRes,
+    internals_API as API,
+    internals_forRegions as forRegions,
+  };
+}
+
+declare type JSON = string | number | boolean | null | JSON[] | {
+    [key: string]: JSON;
+};
+declare type JSONObject = {
+    [key: string]: JSON;
+};
+
+/**
+ * Scaleway error.
+ *
+ * @public
+ */
+declare class ScalewayError extends Error {
+    readonly status: number;
+    readonly body: JSONObject | string;
+    readonly message: string;
+    constructor(status: number, body: JSONObject | string, message?: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ScalewayError | null;
+}
+
+/**
+ * AlreadyExists error is used when a resource already exists.
+ *
+ * @public
+ */
+declare class AlreadyExistsError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    readonly helpMessage: string;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string, helpMessage: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): AlreadyExistsError | null;
+}
+
+/**
+ * DeniedAuthentication error is used by the API Gateway auth service to deny a request.
+ *
+ * @public
+ */
+declare class DeniedAuthenticationError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly method: string;
+    readonly reason: string;
+    constructor(status: number, body: JSONObject, method: string, reason: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): DeniedAuthenticationError | null;
+}
+
+/**
+ * Details of an {@link InvalidArgumentsError} error.
+ *
+ * @internal
+ */
+declare type InvalidArgumentsErrorDetails = {
+    readonly argumentName: string;
+    readonly reason: string;
+    readonly helpMessage?: string;
+};
+/**
+ * InvalidArguments error happens when one or many fields are invalid in the request message.
+ *
+ * @public
+ */
+declare class InvalidArgumentsError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly details: Array<InvalidArgumentsErrorDetails>;
+    constructor(status: number, body: JSONObject, details: Array<InvalidArgumentsErrorDetails>);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): InvalidArgumentsError | null;
+}
+
+/**
+ * OutOfStock error happens when stocks are empty for the resource.
+ *
+ * @public
+ */
+declare class OutOfStockError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    constructor(status: number, body: JSONObject, resource: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): OutOfStockError | null;
+}
+
+/**
+ * Details of an {@link PermissionsDeniedError} error.
+ *
+ * @public
+ */
+declare type PermissionsDeniedErrorDetails = {
+    readonly resource: string;
+    readonly action: string;
+};
+/**
+ * PermissionsDenied error happens when one or many permissions are not accorded to the user making the request.
+ *
+ * @public
+ */
+declare class PermissionsDeniedError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly list: Array<PermissionsDeniedErrorDetails>;
+    constructor(status: number, body: JSONObject, list: Array<PermissionsDeniedErrorDetails>);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ScalewayError | null;
+}
+
+/**
+ * PreconditionFailed error is used when a precondition is not respected.
+ *
+ * @public
+ */
+declare class PreconditionFailedError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly precondition: string;
+    readonly helpMessage: string;
+    constructor(status: number, body: JSONObject, precondition: string, helpMessage: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): PreconditionFailedError | null;
+}
+
+/**
+ * Scope of an {@link QuotasExceededErrorDetails} error.
+ *
+ * @public
+ */
+declare type QuotasExceededErrorScope = {
+    kind: 'organization' | 'project';
+    id: string;
+};
+/**
+ * Details of an {@link QuotasExceededError} error.
+ *
+ * @public
+ */
+declare type QuotasExceededErrorDetails = {
+    readonly resource: string;
+    readonly quota: number;
+    readonly current: number;
+    readonly scope?: QuotasExceededErrorScope;
+};
+/**
+ * QuotasExceeded error happens when one or many resource exceed quotas during the creation of a resource.
+ *
+ * @public
+ */
+declare class QuotasExceededError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly list: Array<QuotasExceededErrorDetails>;
+    constructor(status: number, body: JSONObject, list: Array<QuotasExceededErrorDetails>);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): QuotasExceededError | null;
+}
+
+/**
+ * ResourceExpired error happens when trying to access a resource that has expired.
+ *
+ * @public
+ */
+declare class ResourceExpiredError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    readonly expiredSince: Date;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string, expiredSince: Date);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ResourceExpiredError | null;
+}
+
+/**
+ * ResourceLocked error happens when a resource is locked by trust and safety.
+ *
+ * @public
+ */
+declare class ResourceLockedError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ResourceLockedError | null;
+}
+
+/**
+ * ResourceNotFound error happens when getting a resource that does not exist anymore.
+ *
+ * @public
+ */
+declare class ResourceNotFoundError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ResourceNotFoundError | null;
+}
+
+/**
+ * TransientState error happens when trying to perform an action on a resource in a transient state.
+ *
+ * @public
+ */
+declare class TransientStateError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    readonly currentState: string;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string, currentState: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ScalewayError | null;
+}
+
+type index_ScalewayError = ScalewayError;
+declare const index_ScalewayError: typeof ScalewayError;
+type index_AlreadyExistsError = AlreadyExistsError;
+declare const index_AlreadyExistsError: typeof AlreadyExistsError;
+type index_DeniedAuthenticationError = DeniedAuthenticationError;
+declare const index_DeniedAuthenticationError: typeof DeniedAuthenticationError;
+type index_InvalidArgumentsError = InvalidArgumentsError;
+declare const index_InvalidArgumentsError: typeof InvalidArgumentsError;
+type index_OutOfStockError = OutOfStockError;
+declare const index_OutOfStockError: typeof OutOfStockError;
+type index_PermissionsDeniedError = PermissionsDeniedError;
+declare const index_PermissionsDeniedError: typeof PermissionsDeniedError;
+type index_PreconditionFailedError = PreconditionFailedError;
+declare const index_PreconditionFailedError: typeof PreconditionFailedError;
+type index_QuotasExceededError = QuotasExceededError;
+declare const index_QuotasExceededError: typeof QuotasExceededError;
+type index_ResourceExpiredError = ResourceExpiredError;
+declare const index_ResourceExpiredError: typeof ResourceExpiredError;
+type index_ResourceLockedError = ResourceLockedError;
+declare const index_ResourceLockedError: typeof ResourceLockedError;
+type index_ResourceNotFoundError = ResourceNotFoundError;
+declare const index_ResourceNotFoundError: typeof ResourceNotFoundError;
+type index_TransientStateError = TransientStateError;
+declare const index_TransientStateError: typeof TransientStateError;
+declare namespace index {
+  export {
+    index_ScalewayError as ScalewayError,
+    index_AlreadyExistsError as AlreadyExistsError,
+    index_DeniedAuthenticationError as DeniedAuthenticationError,
+    index_InvalidArgumentsError as InvalidArgumentsError,
+    index_OutOfStockError as OutOfStockError,
+    index_PermissionsDeniedError as PermissionsDeniedError,
+    index_PreconditionFailedError as PreconditionFailedError,
+    index_QuotasExceededError as QuotasExceededError,
+    index_ResourceExpiredError as ResourceExpiredError,
+    index_ResourceLockedError as ResourceLockedError,
+    index_ResourceNotFoundError as ResourceNotFoundError,
+    index_TransientStateError as TransientStateError,
+  };
+}
+
+declare type ImageStatus = 'unknown' | 'ready' | 'deleting' | 'error' | 'locked';
+declare type ImageVisibility = 'visibility_unknown' | 'inherit' | 'public' | 'private';
+declare type ListImagesRequestOrderBy = 'created_at_asc' | 'created_at_desc' | 'name_asc' | 'name_desc';
+declare type ListNamespacesRequestOrderBy$1 = 'created_at_asc' | 'created_at_desc' | 'description_asc' | 'description_desc' | 'name_asc' | 'name_desc';
+declare type ListTagsRequestOrderBy = 'created_at_asc' | 'created_at_desc' | 'name_asc' | 'name_desc';
+declare type NamespaceStatus$1 = 'unknown' | 'ready' | 'deleting' | 'error' | 'locked';
+declare type TagStatus = 'unknown' | 'ready' | 'deleting' | 'error' | 'locked';
+interface Image {
+    id: string;
+    name: string;
+    namespaceId: string;
+    status: ImageStatus;
+    statusMessage?: string;
+    visibility: ImageVisibility;
+    size: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    tags: string[];
+}
+interface Namespace$1 {
+    id: string;
+    name: string;
+    description: string;
+    organizationId: string;
+    projectId: string;
+    status: NamespaceStatus$1;
+    statusMessage: string;
+    endpoint: string;
+    isPublic: boolean;
+    size: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    imageCount: number;
+    region: Region;
+}
+interface Tag {
+    id: string;
+    name: string;
+    imageId: string;
+    status: TagStatus;
+    digest: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+interface ListImagesResponse extends PaginatedResponse {
+    images: Image[];
+}
+interface ListNamespacesResponse$1 extends PaginatedResponse {
+    namespaces: Namespace$1[];
+}
+interface ListTagsResponse extends PaginatedResponse {
+    tags: Tag[];
+}
+declare type ListNamespacesRequest$1 = {
+    region?: Region;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListNamespacesRequestOrderBy$1;
+    organizationId?: string;
+    projectId?: string;
+    name?: string;
+};
+declare type ListImagesRequest = {
+    region?: Region;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListImagesRequestOrderBy;
+    namespaceId?: string;
+    name?: string;
+    organizationId?: string;
+    projectId?: string;
+};
+declare type GetNamespaceRequest$1 = {
+    region?: Region;
+    namespaceId: string;
+};
+declare type CreateNamespaceRequest$1 = {
+    region?: Region;
+    name: string;
+    description: string;
+    projectId?: string;
+    organizationId?: string;
+    isPublic: boolean;
+};
+declare type UpdateNamespaceRequest$1 = {
+    region?: Region;
+    namespaceId: string;
+    description?: string;
+    isPublic?: boolean;
+};
+declare type DeleteNamespaceRequest$1 = {
+    region?: Region;
+    namespaceId: string;
+};
+declare type GetImageRequest = {
+    region?: Region;
+    imageId: string;
+};
+declare type UpdateImageRequest = {
+    region?: Region;
+    imageId: string;
+    visibility: ImageVisibility;
+};
+declare type DeleteImageRequest = {
+    region?: Region;
+    imageId: string;
+};
+declare type ListTagsRequest = {
+    region?: Region;
+    imageId: string;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListTagsRequestOrderBy;
+    name?: string;
+};
+declare type GetTagRequest = {
+    region?: Region;
+    tagId: string;
+};
+declare type DeleteTagRequest = {
+    region?: Region;
+    tagId: string;
+    force: boolean;
+};
+
+type types$1_ImageStatus = ImageStatus;
+type types$1_ImageVisibility = ImageVisibility;
+type types$1_ListImagesRequestOrderBy = ListImagesRequestOrderBy;
+type types$1_ListTagsRequestOrderBy = ListTagsRequestOrderBy;
+type types$1_TagStatus = TagStatus;
+type types$1_Image = Image;
+type types$1_Tag = Tag;
+type types$1_ListImagesResponse = ListImagesResponse;
+type types$1_ListTagsResponse = ListTagsResponse;
+type types$1_ListImagesRequest = ListImagesRequest;
+type types$1_GetImageRequest = GetImageRequest;
+type types$1_UpdateImageRequest = UpdateImageRequest;
+type types$1_DeleteImageRequest = DeleteImageRequest;
+type types$1_ListTagsRequest = ListTagsRequest;
+type types$1_GetTagRequest = GetTagRequest;
+type types$1_DeleteTagRequest = DeleteTagRequest;
+declare namespace types$1 {
+  export {
+    types$1_ImageStatus as ImageStatus,
+    types$1_ImageVisibility as ImageVisibility,
+    types$1_ListImagesRequestOrderBy as ListImagesRequestOrderBy,
+    ListNamespacesRequestOrderBy$1 as ListNamespacesRequestOrderBy,
+    types$1_ListTagsRequestOrderBy as ListTagsRequestOrderBy,
+    NamespaceStatus$1 as NamespaceStatus,
+    types$1_TagStatus as TagStatus,
+    types$1_Image as Image,
+    Namespace$1 as Namespace,
+    types$1_Tag as Tag,
+    types$1_ListImagesResponse as ListImagesResponse,
+    ListNamespacesResponse$1 as ListNamespacesResponse,
+    types$1_ListTagsResponse as ListTagsResponse,
+    ListNamespacesRequest$1 as ListNamespacesRequest,
+    types$1_ListImagesRequest as ListImagesRequest,
+    GetNamespaceRequest$1 as GetNamespaceRequest,
+    CreateNamespaceRequest$1 as CreateNamespaceRequest,
+    UpdateNamespaceRequest$1 as UpdateNamespaceRequest,
+    DeleteNamespaceRequest$1 as DeleteNamespaceRequest,
+    types$1_GetImageRequest as GetImageRequest,
+    types$1_UpdateImageRequest as UpdateImageRequest,
+    types$1_DeleteImageRequest as DeleteImageRequest,
+    types$1_ListTagsRequest as ListTagsRequest,
+    types$1_GetTagRequest as GetTagRequest,
+    types$1_DeleteTagRequest as DeleteTagRequest,
+  };
+}
+
+declare type WaitForOptions = {
+    timeout?: number;
+    retryInterval?: number;
+};
+
+declare abstract class WaitForRegistryAPI extends API {
+    abstract getNamespace: (request: GetNamespaceRequest$1) => Promise<Namespace$1>;
+    abstract getImage: (request: GetImageRequest) => Promise<Image>;
+    abstract getTag: (request: GetTagRequest) => Promise<Tag>;
+    waitForNamespace: (request: Readonly<GetNamespaceRequest$1>, options?: Readonly<WaitForOptions> | undefined) => Promise<Namespace$1>;
+    waitForImage: (request: Readonly<GetImageRequest>, options?: Readonly<WaitForOptions> | undefined) => Promise<Image>;
+    waitForTag: (request: Readonly<GetTagRequest>, options?: Readonly<WaitForOptions> | undefined) => Promise<Tag>;
+}
+
+declare class RegistryAPI extends WaitForRegistryAPI {
+    createNamespace: ({ region, ...req }: Readonly<CreateNamespaceRequest$1>) => Promise<Namespace$1>;
+    updateNamespace: ({ region, ...req }: Readonly<UpdateNamespaceRequest$1>) => Promise<Namespace$1>;
+    getNamespace: ({ region, ...req }: Readonly<GetNamespaceRequest$1>) => Promise<Namespace$1>;
+    private listNamespaces;
+    paginateNamespaces: (request?: Readonly<ListNamespacesRequest$1>) => AsyncGenerator<Namespace$1[], void, number | undefined>;
+    listAllNamespaces: (request?: Readonly<ListNamespacesRequest$1>) => Promise<Namespace$1[]>;
+    deleteNamespace: ({ region, ...req }: Readonly<DeleteNamespaceRequest$1>) => Promise<Namespace$1>;
+    updateImage: ({ region, ...req }: Readonly<UpdateImageRequest>) => Promise<Image>;
+    getImage: ({ region, ...req }: Readonly<GetImageRequest>) => Promise<Image>;
+    private listImages;
+    paginateImages: (request?: Readonly<ListImagesRequest>) => AsyncGenerator<Image[], void, number | undefined>;
+    listAllImages: (request?: Readonly<ListImagesRequest>) => Promise<Image[]>;
+    deleteImage: ({ region, ...req }: Readonly<DeleteImageRequest>) => Promise<Image>;
+    getTag: ({ region, ...req }: Readonly<GetTagRequest>) => Promise<Tag>;
+    private listTags;
+    paginateTags: (request: ListTagsRequest) => AsyncGenerator<Tag[], void, number | undefined>;
+    listAllTags: (request: ListTagsRequest) => Promise<Tag[]>;
+    deleteTag: ({ region, ...req }: Readonly<DeleteTagRequest>) => Promise<Tag>;
+}
+
+declare type NamespaceStatus = 'unknown' | 'ready' | 'deleting' | 'error' | 'locked' | 'creating' | 'pending';
+declare type ListNamespacesRequestOrderBy = 'created_at_asc' | 'created_at_desc' | 'name_asc' | 'name_desc';
+declare type FunctionRuntime = 'unknown_runtime' | 'golang' | 'python' | 'python3' | 'node8' | 'node10' | 'node14';
+declare type FunctionStatus = 'unknown' | 'ready' | 'deleting' | 'error' | 'locked' | 'creating' | 'pending' | 'created';
+declare type FunctionPrivacy = 'unknown_privacy' | 'public' | 'private';
+declare type ListFunctionsRequestOrderBy = 'created_at_asc' | 'created_at_desc' | 'name_asc' | 'name_desc';
+declare type DomainStatus = 'unknown' | 'ready' | 'deleting' | 'error' | 'creating' | 'pending';
+declare type ListDomainsRequestOrderBy = 'created_at_asc' | 'created_at_desc' | 'hostname_asc' | 'hostname_desc';
+declare type CronStatus = 'unknown' | 'ready' | 'deleting' | 'error' | 'locked' | 'creating' | 'pending';
+declare type ListCronsRequestOrderBy = 'created_at_asc' | 'created_at_desc';
+declare type ListLogsRequestOrderBy = 'timestamp_desc' | 'timestamp_asc';
+interface Cron {
+    id: string;
+    functionId: string;
+    schedule: string;
+    args: object;
+    status: CronStatus;
+}
+interface Namespace {
+    id: string;
+    name: string;
+    environmentVariables: Record<string, string>;
+    organizationId: string;
+    projectId: string;
+    status: NamespaceStatus;
+    registryNamespaceId: string;
+    errorMessage?: string;
+    registryEndpoint: string;
+    description?: string;
+    region: Region;
+}
+interface Function {
+    id: string;
+    name: string;
+    namespaceId: string;
+    status: FunctionStatus;
+    environmentVariables: Record<string, string>;
+    minScale: number;
+    maxScale: number;
+    runtime: FunctionRuntime;
+    memoryLimit: number;
+    cpuLimit: number;
+    timeout?: string;
+    handler: string;
+    errorMessage?: string;
+    privacy: FunctionPrivacy;
+    description?: string;
+    region: Region;
+}
+interface Domain {
+    id: string;
+    hostname: string;
+    functionId: string;
+    url: string;
+    status: DomainStatus;
+    errorMessage?: string;
+}
+interface Log {
+    message: string;
+    timestamp: number;
+    id: string;
+}
+interface UploadURL {
+    url: string;
+    headers: Record<string, string>;
+}
+interface DownloadURL {
+    url: string;
+    headers: Record<string, string>;
+}
+interface Token {
+    token: string;
+    publicKey: string;
+}
+declare type ListNamespacesRequest = {
+    region?: Region;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListNamespacesRequestOrderBy;
+    organizationId?: string;
+    projectId?: string;
+    name?: string;
+};
+interface ListNamespacesResponse extends PaginatedResponse {
+    namespaces: Namespace[];
+}
+declare type GetNamespaceRequest = {
+    region?: Region;
+    namespaceId: string;
+};
+declare type CreateNamespaceRequest = {
+    region?: Region;
+    projectId?: string;
+    name: string;
+    environmentVariables?: Record<string, string>;
+    description?: string;
+};
+declare type UpdateNamespaceRequest = {
+    region?: Region;
+    namespaceId: string;
+    environmentVariables?: Record<string, string>;
+    description?: string;
+};
+declare type DeleteNamespaceRequest = {
+    region?: Region;
+    namespaceId: string;
+};
+declare type IssueJWTRequest = {
+    region?: Region;
+    functionId?: string;
+    namespaceId?: string;
+    expiresAt?: Date;
+};
+declare type ListFunctionsRequest = {
+    region?: Region;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListFunctionsRequestOrderBy;
+    namespaceId?: string;
+    name?: string;
+    organizationId?: string;
+    projectId?: string;
+};
+interface ListFunctionsResponse extends PaginatedResponse {
+    functions: Function[];
+}
+declare type GetFunctionRequest = {
+    region?: Region;
+    functionId: string;
+};
+declare type CreateFunctionRequest = {
+    region?: Region;
+    namespaceId: string;
+    name: string;
+    environmentVariables?: Record<string, string>;
+    minScale?: number;
+    maxScale?: number;
+    runtime: FunctionRuntime;
+    memoryLimit?: number;
+    timeout?: string;
+    handler?: string;
+    privacy?: FunctionPrivacy;
+    description?: string;
+};
+declare type UpdateFunctionRequest = {
+    region?: Region;
+    functionId: string;
+    environmentVariables?: Record<string, string>;
+    minScale?: number;
+    maxScale?: number;
+    memoryLimit?: number;
+    timeout?: string;
+    redeploy?: boolean;
+    handler?: string;
+    privacy?: FunctionPrivacy;
+    description?: string;
+};
+declare type DeleteFunctionRequest = {
+    region?: Region;
+    functionId: string;
+};
+declare type DeployFunctionRequest = {
+    region?: Region;
+    functionId: string;
+};
+declare type GetFunctionUploadURLRequest = {
+    region?: Region;
+    functionId: string;
+    contentLength: number;
+};
+declare type GetFunctionDownloadURLRequest = {
+    region?: Region;
+    functionId: string;
+};
+declare type ListFunctionRuntimesRequest = {
+    region?: Region;
+};
+declare type ListFunctionRuntimesResponse = {
+    runtimes: FunctionRuntime[];
+};
+declare type ListCronsRequest = {
+    region?: Region;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListCronsRequestOrderBy;
+    functionId: string;
+};
+interface ListCronsResponse extends PaginatedResponse {
+    crons: Cron[];
+}
+declare type GetCronRequest = {
+    region?: Region;
+    cronId: string;
+};
+declare type CreateCronRequest = {
+    region?: Region;
+    functionId: string;
+    schedule: string;
+    args: object;
+};
+declare type DeleteCronRequest = {
+    region?: Region;
+    cronId: string;
+};
+declare type UpdateCronRequest = {
+    region?: Region;
+    cronId: string;
+    functionId?: string;
+    schedule?: string;
+    args: object;
+};
+declare type ListLogsRequest = {
+    region?: Region;
+    functionId: string;
+    page?: number;
+    pageSize?: number;
+    orderBy?: ListLogsRequestOrderBy;
+};
+interface ListLogsResponse extends PaginatedResponse {
+    logs: Log[];
+}
+
+type types_NamespaceStatus = NamespaceStatus;
+type types_ListNamespacesRequestOrderBy = ListNamespacesRequestOrderBy;
+type types_FunctionRuntime = FunctionRuntime;
+type types_FunctionStatus = FunctionStatus;
+type types_FunctionPrivacy = FunctionPrivacy;
+type types_ListFunctionsRequestOrderBy = ListFunctionsRequestOrderBy;
+type types_DomainStatus = DomainStatus;
+type types_ListDomainsRequestOrderBy = ListDomainsRequestOrderBy;
+type types_CronStatus = CronStatus;
+type types_ListCronsRequestOrderBy = ListCronsRequestOrderBy;
+type types_ListLogsRequestOrderBy = ListLogsRequestOrderBy;
+type types_Cron = Cron;
+type types_Namespace = Namespace;
+type types_Function = Function;
+type types_Domain = Domain;
+type types_Log = Log;
+type types_UploadURL = UploadURL;
+type types_DownloadURL = DownloadURL;
+type types_Token = Token;
+type types_ListNamespacesRequest = ListNamespacesRequest;
+type types_ListNamespacesResponse = ListNamespacesResponse;
+type types_GetNamespaceRequest = GetNamespaceRequest;
+type types_CreateNamespaceRequest = CreateNamespaceRequest;
+type types_UpdateNamespaceRequest = UpdateNamespaceRequest;
+type types_DeleteNamespaceRequest = DeleteNamespaceRequest;
+type types_IssueJWTRequest = IssueJWTRequest;
+type types_ListFunctionsRequest = ListFunctionsRequest;
+type types_ListFunctionsResponse = ListFunctionsResponse;
+type types_GetFunctionRequest = GetFunctionRequest;
+type types_CreateFunctionRequest = CreateFunctionRequest;
+type types_UpdateFunctionRequest = UpdateFunctionRequest;
+type types_DeleteFunctionRequest = DeleteFunctionRequest;
+type types_DeployFunctionRequest = DeployFunctionRequest;
+type types_GetFunctionUploadURLRequest = GetFunctionUploadURLRequest;
+type types_GetFunctionDownloadURLRequest = GetFunctionDownloadURLRequest;
+type types_ListFunctionRuntimesRequest = ListFunctionRuntimesRequest;
+type types_ListFunctionRuntimesResponse = ListFunctionRuntimesResponse;
+type types_ListCronsRequest = ListCronsRequest;
+type types_ListCronsResponse = ListCronsResponse;
+type types_GetCronRequest = GetCronRequest;
+type types_CreateCronRequest = CreateCronRequest;
+type types_DeleteCronRequest = DeleteCronRequest;
+type types_UpdateCronRequest = UpdateCronRequest;
+type types_ListLogsRequest = ListLogsRequest;
+type types_ListLogsResponse = ListLogsResponse;
+declare namespace types {
+  export {
+    types_NamespaceStatus as NamespaceStatus,
+    types_ListNamespacesRequestOrderBy as ListNamespacesRequestOrderBy,
+    types_FunctionRuntime as FunctionRuntime,
+    types_FunctionStatus as FunctionStatus,
+    types_FunctionPrivacy as FunctionPrivacy,
+    types_ListFunctionsRequestOrderBy as ListFunctionsRequestOrderBy,
+    types_DomainStatus as DomainStatus,
+    types_ListDomainsRequestOrderBy as ListDomainsRequestOrderBy,
+    types_CronStatus as CronStatus,
+    types_ListCronsRequestOrderBy as ListCronsRequestOrderBy,
+    types_ListLogsRequestOrderBy as ListLogsRequestOrderBy,
+    types_Cron as Cron,
+    types_Namespace as Namespace,
+    types_Function as Function,
+    types_Domain as Domain,
+    types_Log as Log,
+    types_UploadURL as UploadURL,
+    types_DownloadURL as DownloadURL,
+    types_Token as Token,
+    types_ListNamespacesRequest as ListNamespacesRequest,
+    types_ListNamespacesResponse as ListNamespacesResponse,
+    types_GetNamespaceRequest as GetNamespaceRequest,
+    types_CreateNamespaceRequest as CreateNamespaceRequest,
+    types_UpdateNamespaceRequest as UpdateNamespaceRequest,
+    types_DeleteNamespaceRequest as DeleteNamespaceRequest,
+    types_IssueJWTRequest as IssueJWTRequest,
+    types_ListFunctionsRequest as ListFunctionsRequest,
+    types_ListFunctionsResponse as ListFunctionsResponse,
+    types_GetFunctionRequest as GetFunctionRequest,
+    types_CreateFunctionRequest as CreateFunctionRequest,
+    types_UpdateFunctionRequest as UpdateFunctionRequest,
+    types_DeleteFunctionRequest as DeleteFunctionRequest,
+    types_DeployFunctionRequest as DeployFunctionRequest,
+    types_GetFunctionUploadURLRequest as GetFunctionUploadURLRequest,
+    types_GetFunctionDownloadURLRequest as GetFunctionDownloadURLRequest,
+    types_ListFunctionRuntimesRequest as ListFunctionRuntimesRequest,
+    types_ListFunctionRuntimesResponse as ListFunctionRuntimesResponse,
+    types_ListCronsRequest as ListCronsRequest,
+    types_ListCronsResponse as ListCronsResponse,
+    types_GetCronRequest as GetCronRequest,
+    types_CreateCronRequest as CreateCronRequest,
+    types_DeleteCronRequest as DeleteCronRequest,
+    types_UpdateCronRequest as UpdateCronRequest,
+    types_ListLogsRequest as ListLogsRequest,
+    types_ListLogsResponse as ListLogsResponse,
+  };
+}
+
+declare abstract class WaitForFunctionAPI extends API {
+    abstract getNamespace: (request: GetNamespaceRequest) => Promise<Namespace>;
+    abstract getFunction: (request: GetFunctionRequest) => Promise<Function>;
+    abstract getCron: (request: GetCronRequest) => Promise<Cron>;
+    waitForNamespace: (request: Readonly<GetNamespaceRequest>, options?: Readonly<WaitForOptions> | undefined) => Promise<Namespace>;
+    waitForFunction: (request: Readonly<GetFunctionRequest>, options?: Readonly<WaitForOptions> | undefined) => Promise<Function>;
+    waitForCron: (request: Readonly<GetCronRequest>, options?: Readonly<WaitForOptions> | undefined) => Promise<Cron>;
+}
+
+declare class FunctionAPI extends WaitForFunctionAPI {
+    private listNamespaces;
+    paginateNamespaces: (request?: Readonly<ListNamespacesRequest>) => AsyncGenerator<Namespace[], void, number | undefined>;
+    listAllNamespaces: (request?: Readonly<ListNamespacesRequest>) => Promise<Namespace[]>;
+    getNamespace: ({ region, ...req }: Readonly<GetNamespaceRequest>) => Promise<Namespace>;
+    createNamespace: ({ projectId, region, ...req }: Readonly<CreateNamespaceRequest>) => Promise<Namespace>;
+    updateNamespace: ({ region, ...req }: Readonly<UpdateNamespaceRequest>) => Promise<Namespace>;
+    deleteNamespace: ({ region, ...req }: Readonly<DeleteNamespaceRequest>) => Promise<Namespace>;
+    private listFunctions;
+    paginateFunctions: (request?: Readonly<ListFunctionsRequest>) => AsyncGenerator<Function[], void, number | undefined>;
+    listAllFunctions: (request?: Readonly<ListFunctionsRequest>) => Promise<Function[]>;
+    getFunction: ({ region, ...req }: Readonly<GetFunctionRequest>) => Promise<Function>;
+    createFunction: ({ region, ...req }: Readonly<CreateFunctionRequest>) => Promise<Function>;
+    updateFunction: ({ region, ...req }: Readonly<UpdateFunctionRequest>) => Promise<Function>;
+    deleteFunction: ({ region, ...req }: Readonly<DeleteFunctionRequest>) => Promise<Function>;
+    deployFunction: ({ region, ...req }: Readonly<DeployFunctionRequest>) => Promise<Function>;
+    getFunctionUploadURL: ({ region, ...req }: Readonly<GetFunctionUploadURLRequest>) => Promise<UploadURL>;
+    getFunctionDownloadURL: ({ region, ...req }: Readonly<GetFunctionDownloadURLRequest>) => Promise<DownloadURL>;
+    listFunctionRuntimes: ({ region, }?: Readonly<ListFunctionRuntimesRequest>) => Promise<ListFunctionRuntimesResponse>;
+    listLogs: ({ region, orderBy, ...req }: Readonly<ListLogsRequest>) => Promise<ListLogsResponse>;
+    private listCrons;
+    paginateCrons: (request: Readonly<ListCronsRequest>) => AsyncGenerator<Cron[], void, number | undefined>;
+    listAllCrons: (request: Readonly<ListCronsRequest>) => Promise<Cron[]>;
+    getCron: ({ region, ...req }: Readonly<GetCronRequest>) => Promise<Cron>;
+    createCron: ({ region, ...req }: Readonly<CreateCronRequest>) => Promise<Cron>;
+    updateCron: ({ region, ...req }: Readonly<UpdateCronRequest>) => Promise<Cron>;
+    deleteCron: ({ region, ...req }: Readonly<DeleteCronRequest>) => Promise<Cron>;
+    issueJWT: ({ region, ...req }: Readonly<IssueJWTRequest>) => Promise<Token>;
+}
+
+export { ClientConfig, index as Errors, FunctionAPI, types as FunctionNS, Logger, Profile, RegistryAPI, types$1 as RegistryNS, ScwClient, Settings, createAdvancedScwClient, createScwClient, enableConsoleLogger, internals, setLogger, withProfile };