@silkline/arena 1.0.0

package/src/resources/items/items_.ts

@@ -0,0 +1,125 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as ImageAPI from './image';
+import * as ItemsAPI from './items';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Items extends APIResource {
+  /**
+   * Creates a new Item-to-Item reference for an item with a given GUID.
+   *
+   * <b>Notes:</b>
+   *
+   * 1. Item references are bidirectional. Creating an Item reference between Items
+   *    means both Items will appear in each other's Items view.
+   * 2. References are not revision controlled or revision specific, and can only be
+   *    created between released Items.
+   */
+  create(itemGuid: string, body: ItemCreateParams, options?: RequestOptions): APIPromise<ItemToItem> {
+    return this._client.post(path`/items/${itemGuid}/items`, { body, ...options });
+  }
+
+  /**
+   * Retrieve detailed information of the specified reference item
+   */
+  retrieve(
+    itemReferenceGuid: string,
+    params: ItemRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<ItemToItem> {
+    const { itemGuid } = params;
+    return this._client.get(path`/items/${itemGuid}/items/${itemReferenceGuid}`, options);
+  }
+
+  /**
+   * Updates the metadata of an Item-To-Item reference with a given GUID
+   */
+  update(
+    itemReferenceGuid: string,
+    params: ItemUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<ItemToItem> {
+    const { itemGuid, ...body } = params;
+    return this._client.put(path`/items/${itemGuid}/items/${itemReferenceGuid}`, { body, ...options });
+  }
+
+  /**
+   * Retrieve reference item collection of the item
+   */
+  list(itemGuid: string, options?: RequestOptions): APIPromise<ItemListResponse> {
+    return this._client.get(path`/items/${itemGuid}/items`, options);
+  }
+
+  /**
+   * Deletes an source Item reference with a given GUID for an item with a given
+   * GUID.
+   */
+  delete(itemReferenceGuid: string, params: ItemDeleteParams, options?: RequestOptions): APIPromise<string> {
+    const { itemGuid } = params;
+    return this._client.delete(path`/items/${itemGuid}/items/${itemReferenceGuid}`, options);
+  }
+}
+
+export interface ItemGuidAndURL {
+  guid?: string;
+
+  url?: ItemsAPI.URL;
+}
+
+export interface ItemToItem {
+  guid?: string;
+
+  item?: ItemGuidAndURL;
+
+  notes?: string;
+}
+
+export interface ItemListResponse {
+  count?: number;
+
+  results?: Array<ItemToItem>;
+}
+
+export type ItemDeleteResponse = string;
+
+export interface ItemCreateParams {
+  item?: ImageAPI.SingleGuid;
+
+  note?: string;
+}
+
+export interface ItemRetrieveParams {
+  itemGuid: string;
+}
+
+export interface ItemUpdateParams {
+  /**
+   * Path param:
+   */
+  itemGuid: string;
+
+  /**
+   * Body param:
+   */
+  note?: string;
+}
+
+export interface ItemDeleteParams {
+  itemGuid: string;
+}
+
+export declare namespace Items {
+  export {
+    type ItemGuidAndURL as ItemGuidAndURL,
+    type ItemToItem as ItemToItem,
+    type ItemListResponse as ItemListResponse,
+    type ItemDeleteResponse as ItemDeleteResponse,
+    type ItemCreateParams as ItemCreateParams,
+    type ItemRetrieveParams as ItemRetrieveParams,
+    type ItemUpdateParams as ItemUpdateParams,
+    type ItemDeleteParams as ItemDeleteParams,
+  };
+}

package/src/resources/items/quality.ts

@@ -0,0 +1,55 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as TicketsQualityAPI from '../tickets/quality';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Quality extends APIResource {
+  /**
+   * Retrieve detailed information of the specified reference quality process
+   */
+  retrieve(
+    itemQualityAssociationGuid: string,
+    params: QualityRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<ItemQuality> {
+    const { itemGuid } = params;
+    return this._client.get(path`/items/${itemGuid}/quality/${itemQualityAssociationGuid}`, options);
+  }
+
+  /**
+   * Returns a collection of Quality Process objects for an item with a given GUID
+   * (all Quality Processes in which the Item is an affected object).
+   */
+  list(itemGuid: string, options?: RequestOptions): APIPromise<QualityListResponse> {
+    return this._client.get(path`/items/${itemGuid}/quality`, options);
+  }
+}
+
+export interface ItemQuality {
+  guid?: string;
+
+  notes?: string;
+
+  qualityProcess?: TicketsQualityAPI.QualityProcessReference;
+}
+
+export interface QualityListResponse {
+  count?: number;
+
+  results?: Array<ItemQuality>;
+}
+
+export interface QualityRetrieveParams {
+  itemGuid: string;
+}
+
+export declare namespace Quality {
+  export {
+    type ItemQuality as ItemQuality,
+    type QualityListResponse as QualityListResponse,
+    type QualityRetrieveParams as QualityRetrieveParams,
+  };
+}

package/src/resources/items/sourcing.ts

@@ -0,0 +1,212 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as FilesAPI from '../files/files';
+import * as ImageAPI from './image';
+import * as ItemsAPI from '../requests/items';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Sourcing extends APIResource {
+  /**
+   * Creates a new Source Relationship for an item with a given GUID.
+   *
+   * You can create two types of source relationship: &bull; <b>Direct
+   * relationship</b>: You get a manufacturer Item directly from the manufacturer.
+   * The manufacturer and vendor items are the same. You can also specify a Make-Item
+   * relationship (where your own company makes the part) by setting
+   * <code>MakeItem</code> to True. &bull; <b>Indirect relationship</b>: You buy a
+   * manufacturer item from a vendor. The manufacturer and vendor items are
+   * different. You can also create an 'any' relationship by omitting the
+   * manufacturer or vendor item.
+   *
+   * <b>Notes:</b>
+   *
+   * 1. The suppliers and supplier items named in the source relationship must
+   *    already exist in the workspace. Find their GUIDs with Get Supplier and Get
+   *    Supplier Item requests.
+   * 2. Attribute values must match the types specified in the workspace. For
+   *    predefined lists, use allowed values.
+   * 3. Number values must appear in quotation marks.
+   */
+  create(itemGuid: string, body: SourcingCreateParams, options?: RequestOptions): APIPromise<ItemSourcing> {
+    return this._client.post(path`/items/${itemGuid}/sourcing`, { body, ...options });
+  }
+
+  /**
+   * Returns a Source Relationship object with a given GUID for an item with a given
+   * GUID.
+   */
+  retrieve(
+    sourcingRelationshipGuid: string,
+    params: SourcingRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<ItemSourcing> {
+    const { itemGuid } = params;
+    return this._client.get(path`/items/${itemGuid}/sourcing/${sourcingRelationshipGuid}`, options);
+  }
+
+  /**
+   * Updates a Source Relationship object with a given GUID for an item with a given
+   * GUID. Note that updating a source relationship modifies the existing Source
+   * Relationship GUID on the working revision.
+   */
+  update(
+    sourcingRelationshipGuid: string,
+    params: SourcingUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<ItemSourcing> {
+    const { itemGuid, setnull, ...body } = params;
+    return this._client.put(path`/items/${itemGuid}/sourcing/${sourcingRelationshipGuid}`, {
+      query: { setnull },
+      body,
+      ...options,
+    });
+  }
+
+  /**
+   * Returns an array of Source Relationship objects for an item with a given GUID.
+   */
+  list(itemGuid: string, options?: RequestOptions): APIPromise<ItemSourcingResult> {
+    return this._client.get(path`/items/${itemGuid}/sourcing`, options);
+  }
+
+  /**
+   * Deletes a source relationship with a given GUID for an item with a given GUID.
+   */
+  delete(
+    sourcingRelationshipGuid: string,
+    params: SourcingDeleteParams,
+    options?: RequestOptions,
+  ): APIPromise<string> {
+    const { itemGuid } = params;
+    return this._client.delete(path`/items/${itemGuid}/sourcing/${sourcingRelationshipGuid}`, options);
+  }
+}
+
+export interface ItemSourcing {
+  activeProduction?: boolean;
+
+  activePrototype?: boolean;
+
+  amlRank?: number;
+
+  amlSplit?: number;
+
+  approved?: boolean;
+
+  guid?: string;
+
+  item?: ItemsAPI.ItemShort;
+
+  makeItem?: boolean;
+
+  mrfItem?: SourcingItem;
+
+  notes?: string;
+
+  vendorItem?: SourcingItem;
+
+  vendorItemConversionFactor?: number;
+}
+
+export interface ItemSourcingResult {
+  count?: number;
+
+  results?: Array<ItemSourcing>;
+}
+
+export interface SourcingItem {
+  guid?: string;
+
+  number?: string;
+
+  supplier?: FilesAPI.SupplierCompact;
+}
+
+export type SourcingDeleteResponse = string;
+
+export interface SourcingCreateParams {
+  amlRank?: number;
+
+  approved?: boolean;
+
+  makeItem?: boolean;
+
+  mfrItem?: ImageAPI.SingleGuid;
+
+  notes?: string;
+
+  vendorItem?: ImageAPI.SingleGuid;
+
+  vendorItemConversionFactor?: number;
+}
+
+export interface SourcingRetrieveParams {
+  itemGuid: string;
+}
+
+export interface SourcingUpdateParams {
+  /**
+   * Path param:
+   */
+  itemGuid: string;
+
+  /**
+   * Query param:
+   */
+  setnull?: boolean;
+
+  /**
+   * Body param:
+   */
+  amlRank?: number;
+
+  /**
+   * Body param:
+   */
+  amlSplit?: number;
+
+  /**
+   * Body param:
+   */
+  approved?: boolean;
+
+  /**
+   * Body param:
+   */
+  mfrItem?: ImageAPI.SingleGuid;
+
+  /**
+   * Body param:
+   */
+  notes?: string;
+
+  /**
+   * Body param:
+   */
+  vendorItem?: ImageAPI.SingleGuid;
+
+  /**
+   * Body param:
+   */
+  vendorItemConversionFactor?: number;
+}
+
+export interface SourcingDeleteParams {
+  itemGuid: string;
+}
+
+export declare namespace Sourcing {
+  export {
+    type ItemSourcing as ItemSourcing,
+    type ItemSourcingResult as ItemSourcingResult,
+    type SourcingItem as SourcingItem,
+    type SourcingDeleteResponse as SourcingDeleteResponse,
+    type SourcingCreateParams as SourcingCreateParams,
+    type SourcingRetrieveParams as SourcingRetrieveParams,
+    type SourcingUpdateParams as SourcingUpdateParams,
+    type SourcingDeleteParams as SourcingDeleteParams,
+  };
+}

package/src/resources/items/tickets.ts

@@ -0,0 +1,36 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as TicketsTicketsAPI from '../tickets/tickets_';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Tickets extends APIResource {
+  /**
+   * Retrieve detailed information of the specified validation ticket
+   */
+  retrieve(
+    verifyVerifiesAssociationGuid: string,
+    params: TicketRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<TicketsTicketsAPI.ItemToTicket> {
+    const { itemGuid } = params;
+    return this._client.get(path`/items/${itemGuid}/tickets/${verifyVerifiesAssociationGuid}`, options);
+  }
+
+  /**
+   * Retrieve validation ticket collection of the item
+   */
+  list(itemGuid: string, options?: RequestOptions): APIPromise<TicketsTicketsAPI.ItemTicketResult> {
+    return this._client.get(path`/items/${itemGuid}/tickets`, options);
+  }
+}
+
+export interface TicketRetrieveParams {
+  itemGuid: string;
+}
+
+export declare namespace Tickets {
+  export { type TicketRetrieveParams as TicketRetrieveParams };
+}

package/src/resources/items/trainingplans.ts

@@ -0,0 +1,65 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as TrainingrecordsAPI from './trainingrecords';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Trainingplans extends APIResource {
+  /**
+   * Returns a specific Training Plan associated within a specific Item. Using the
+   * browser-based application as a point of comparison, this endpoint returns a
+   * specific Training Plan located within the Training view, Training Plans subview
+   * of a specific Item.
+   */
+  retrieve(
+    associationGuid: string,
+    params: TrainingplanRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<TrainingplanRetrieveResponse> {
+    const { itemGuid } = params;
+    return this._client.get(path`/items/${itemGuid}/trainingplans/${associationGuid}`, options);
+  }
+
+  /**
+   * Returns all the Training Plans that use a specific Item. Using the browser-based
+   * application as a point of comparison, this endpoint returns the Training Plans
+   * within the Training view, Training Plans subview of a specific Item.
+   */
+  list(itemGuid: string, options?: RequestOptions): APIPromise<TrainingplanListResponse> {
+    return this._client.get(path`/items/${itemGuid}/trainingplans`, options);
+  }
+}
+
+export interface TrainingplanRetrieveResponse {
+  count?: number;
+
+  results?: Array<TrainingplanRetrieveResponse.Result>;
+}
+
+export namespace TrainingplanRetrieveResponse {
+  export interface Result {
+    guid?: string;
+
+    trainingplan?: TrainingrecordsAPI.TrainingMinimal;
+  }
+}
+
+export interface TrainingplanListResponse {
+  count?: number;
+
+  results?: Array<unknown>;
+}
+
+export interface TrainingplanRetrieveParams {
+  itemGuid: string;
+}
+
+export declare namespace Trainingplans {
+  export {
+    type TrainingplanRetrieveResponse as TrainingplanRetrieveResponse,
+    type TrainingplanListResponse as TrainingplanListResponse,
+    type TrainingplanRetrieveParams as TrainingplanRetrieveParams,
+  };
+}

package/src/resources/items/trainingrecords.ts

@@ -0,0 +1,68 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Trainingrecords extends APIResource {
+  /**
+   * Returns a specific Item's training record associated with a specific Training
+   * Plans. Using the browser-based application as a point of comparison, this
+   * endpoint returns a specific training record of a specific Item within the
+   * Records view of a specific Training Plan.
+   */
+  retrieve(
+    trainingRecordGuid: string,
+    params: TrainingrecordRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<ItemTrainingRecord> {
+    const { itemGuid } = params;
+    return this._client.get(path`/items/${itemGuid}/trainingrecords/${trainingRecordGuid}`, options);
+  }
+
+  /**
+   * Returns a specific Item's training records across all the Training Plans it is
+   * associated with. Using the browser-based application as a point of comparison,
+   * this endpoint returns the training records of a specific Item within the Records
+   * view of all Training Plans associated with that Item.
+   */
+  list(itemGuid: string, options?: RequestOptions): APIPromise<TrainingrecordListResponse> {
+    return this._client.get(path`/items/${itemGuid}/trainingrecords`, options);
+  }
+}
+
+export interface ItemTrainingRecord {
+  dueDate?: string;
+
+  guid?: string;
+
+  signedDateTime?: string;
+
+  traningplan?: TrainingMinimal;
+}
+
+export interface TrainingMinimal {
+  guid?: string;
+
+  number?: string;
+}
+
+export interface TrainingrecordListResponse {
+  count?: number;
+
+  results?: Array<ItemTrainingRecord>;
+}
+
+export interface TrainingrecordRetrieveParams {
+  itemGuid: string;
+}
+
+export declare namespace Trainingrecords {
+  export {
+    type ItemTrainingRecord as ItemTrainingRecord,
+    type TrainingMinimal as TrainingMinimal,
+    type TrainingrecordListResponse as TrainingrecordListResponse,
+    type TrainingrecordRetrieveParams as TrainingrecordRetrieveParams,
+  };
+}

package/src/resources/items.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './items/index';

package/src/resources/login.ts

@@ -0,0 +1,109 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+
+export class Login extends APIResource {
+  /**
+   * This logs a valid user into the Arena System and, once authentication is
+   * successful, a JSON response with an access token is returned. The token must be
+   * set in the headers of all subsequent requests for them to be processed
+   * successfully. The API client should add an HTTP header with the name
+   * <code>arena_session_id</code>, the same cookie name as in the Arena Web
+   * Application.
+   *
+   * Note: If you do not specify a <code>workspace_id</code> value in the call, the
+   * API user will log in to its current workspace, or whichever it was last logged
+   * into.
+   *
+   * The response to each Log In request includes the value
+   * <code>workspaceRequestLimit</code>, which is the maximum number of API requests
+   * allowed for your workspace during a 24-hour period. For all responses in the
+   * session, the remaining number of API requests for the current period and the
+   * scheduled time for resetting of the count are included in the HTTP headers.
+   */
+  authenticate(
+    params: LoginAuthenticateParams,
+    options?: RequestOptions,
+  ): APIPromise<LoginAuthenticateResponse> {
+    const { 'Arena-Usage-Reason': arenaUsageReason, ...body } = params;
+    return this._client.post('/login', {
+      body,
+      ...options,
+      headers: buildHeaders([
+        { ...(arenaUsageReason != null ? { 'Arena-Usage-Reason': arenaUsageReason } : undefined) },
+        options?.headers,
+      ]),
+    });
+  }
+}
+
+export interface LoginAuthenticateResponse {
+  arenaSessionId?: string;
+
+  note?: string;
+
+  reason?: string;
+
+  workspaceId?: number;
+
+  workspaceName?: string;
+
+  workspaceRequestLimit?: number;
+}
+
+export interface LoginAuthenticateParams {
+  /**
+   * Body param:
+   */
+  accesstoken?: string;
+
+  /**
+   * Body param:
+   */
+  email?: string;
+
+  /**
+   * Body param:
+   */
+  forceLogin?: boolean;
+
+  /**
+   * Body param:
+   */
+  loginType?: 'ACCESSTOKEN' | 'WEBTOKEN' | 'EMAIL';
+
+  /**
+   * Body param:
+   */
+  password?: string;
+
+  /**
+   * Body param:
+   */
+  reason?: string;
+
+  /**
+   * Body param:
+   */
+  webtoken?: string;
+
+  /**
+   * Body param:
+   */
+  workspaceId?: number;
+
+  /**
+   * Header param: arena api usage reason
+   */
+  'Arena-Usage-Reason'?: string;
+}
+
+export declare namespace Login {
+  export {
+    type LoginAuthenticateResponse as LoginAuthenticateResponse,
+    type LoginAuthenticateParams as LoginAuthenticateParams,
+  };
+}

package/src/resources/logout.ts

@@ -0,0 +1,19 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+
+export class Logout extends APIResource {
+  /**
+   * This invalidates the access token. Once this is processed successfully, the user
+   * cannot use this token to perform any further actions.
+   */
+  invalidate(options?: RequestOptions): APIPromise<void> {
+    return this._client.put('/logout', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}