@tickernelz/paperclip-pro-server 2026.1018.0 → 2026.1022.0

package/node_modules/@opentelemetry/api/dist/trace/link.d.mts

@@ -0,0 +1,35 @@
+import { SpanAttributes } from "./attributes.mjs";
+import { SpanContext } from "./span_context.mjs";
+//#region src/trace/link.d.ts
+/**
+ * A pointer from the current {@link Span} to another span in the same trace or
+ * in a different trace.
+ * Few examples of Link usage.
+ * 1. Batch Processing: A batch of elements may contain elements associated
+ *    with one or more traces/spans. Since there can only be one parent
+ *    SpanContext, Link is used to keep reference to SpanContext of all
+ *    elements in the batch.
+ * 2. Public Endpoint: A SpanContext in incoming client request on a public
+ *    endpoint is untrusted from service provider perspective. In such case it
+ *    is advisable to start a new trace with appropriate sampling decision.
+ *    However, it is desirable to associate incoming SpanContext to new trace
+ *    initiated on service provider side so two traces (from Client and from
+ *    Service Provider) can be correlated.
+ *
+ * @since 1.0.0
+ */
+interface Link {
+  /** The {@link SpanContext} of a linked span. */
+  context: SpanContext;
+  /** A set of {@link SpanAttributes} on the link. */
+  attributes?: SpanAttributes;
+  /**
+   * Count of attributes of the link that were dropped due to collection limits
+   *
+   * @since 1.4.1
+   */
+  droppedAttributesCount?: number;
+}
+//#endregion
+export { Link };
+//# sourceMappingURL=link.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/link.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.mts","names":[],"sources":["../../src/trace/link.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAmBiB;;EAEb,SAAS;;EAET,aAAa;;;;;;EAMb"}

package/node_modules/@opentelemetry/api/dist/trace/span.d.cts

@@ -0,0 +1,139 @@
+import { TimeInput } from "../common/Time.cjs";
+import { Exception } from "../common/Exception.cjs";
+import { SpanAttributeValue, SpanAttributes } from "./attributes.cjs";
+import { SpanContext } from "./span_context.cjs";
+import { SpanStatus } from "./status.cjs";
+import { Link } from "./link.cjs";
+//#region src/trace/span.d.ts
+/**
+ * An interface that represents a span. A span represents a single operation
+ * within a trace. Examples of span might include remote procedure calls or a
+ * in-process function calls to sub-components. A Trace has a single, top-level
+ * "root" Span that in turn may have zero or more child Spans, which in turn
+ * may have children.
+ *
+ * Spans are created by the {@link Tracer.startSpan} method.
+ *
+ * @since 1.0.0
+ */
+interface Span {
+  /**
+   * Returns the {@link SpanContext} object associated with this Span.
+   *
+   * Get an immutable, serializable identifier for this span that can be used
+   * to create new child spans. Returned SpanContext is usable even after the
+   * span ends.
+   *
+   * @returns the SpanContext object associated with this Span.
+   */
+  spanContext(): SpanContext;
+  /**
+   * Sets an attribute to the span.
+   *
+   * Sets a single Attribute with the key and value passed as arguments.
+   *
+   * @param key the key for this attribute.
+   * @param value the value for this attribute. Setting a value null or
+   *              undefined is invalid and will result in undefined behavior.
+   */
+  setAttribute(key: string, value: SpanAttributeValue): this;
+  /**
+   * Sets attributes to the span.
+   *
+   * @param attributes the attributes that will be added.
+   *                   null or undefined attribute values
+   *                   are invalid and will result in undefined behavior.
+   */
+  setAttributes(attributes: SpanAttributes): this;
+  /**
+   * Adds an event to the Span.
+   *
+   * @param name the name of the event.
+   * @param [attributesOrStartTime] the attributes that will be added; these are
+   *     associated with this event. Can be also a start time
+   *     if type is {@type TimeInput} and 3rd param is undefined
+   * @param [startTime] start time of the event.
+   */
+  addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
+  /**
+   * Adds a single link to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param link the link to add.
+   *
+   * @since 1.9.0
+   */
+  addLink(link: Link): this;
+  /**
+   * Adds multiple links to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param links the links to add.
+   *
+   * @since 1.9.0
+   */
+  addLinks(links: Link[]): this;
+  /**
+   * Sets the status of the span.
+   *
+   * By default, a span has status {@link SpanStatusCode.UNSET}.
+   * Calling this method overrides that default.
+   *
+   * The status codes have a total order: `OK > ERROR > UNSET`.
+   *
+   * - Once {@link SpanStatusCode.OK} is set, any further attempts to change
+   *   the status are ignored.
+   * - Any attempt to set {@link SpanStatusCode.UNSET} is always ignored.
+   *
+   * The `message` field is only used when {@link SpanStatusCode.ERROR} is set.
+   * For all other status codes, `message` is ignored.
+   *
+   * @param status The {@link SpanStatus} to set.
+   */
+  setStatus(status: SpanStatus): this;
+  /**
+   * Updates the Span name.
+   *
+   * This will override the name provided via {@link Tracer.startSpan}.
+   *
+   * Upon this update, any sampling behavior based on Span name will depend on
+   * the implementation.
+   *
+   * @param name the Span name.
+   */
+  updateName(name: string): this;
+  /**
+   * Marks the end of Span execution.
+   *
+   * Call to End of a Span MUST not have any effects on child spans. Those may
+   * still be running and can be ended later.
+   *
+   * Do not return `this`. The Span generally should not be used after it
+   * is ended so chaining is not desired in this context.
+   *
+   * @param [endTime] the time to set as Span's end time. If not provided,
+   *     use the current time as the span's end time.
+   */
+  end(endTime?: TimeInput): void;
+  /**
+   * Returns the flag whether this span will be recorded.
+   *
+   * @returns true if this Span is active and recording information like events
+   *     with the `AddEvent` operation and attributes using `setAttributes`.
+   */
+  isRecording(): boolean;
+  /**
+   * Sets exception as a span event
+   * @param exception the exception the only accepted values are string or Error
+   * @param [time] the time to set as Span's event time. If not provided,
+   *     use the current time.
+   */
+  recordException(exception: Exception, time?: TimeInput): void;
+}
+//#endregion
+export { Span };
+//# sourceMappingURL=span.d.cts.map

package/node_modules/@opentelemetry/api/dist/trace/span.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.cts","names":[],"sources":["../../src/trace/span.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAiBiB;;;;;;;;;;EAUb,eAAe;;;;;;;;;;EAUf,aAAa,aAAa,OAAO;;;;;;;;EAQjC,cAAc,YAAY;;;;;;;;;;EAU1B,SAAS,cAAc,wBAAwB,iBAAiB,WAAW,YAAY;;;;;;;;;;;EAWvF,QAAQ,MAAM;;;;;;;;;;;EAWd,SAAS,OAAO;;;;;;;;;;;;;;;;;;EAkBhB,UAAU,QAAQ;;;;;;;;;;;EAWlB,WAAW;;;;;;;;;;;;;EAaX,IAAI,UAAU;;;;;;;EAOd;;;;;;;EAOA,gBAAgB,WAAW,WAAW,OAAO"}

package/node_modules/@opentelemetry/api/dist/trace/span.d.mts

@@ -0,0 +1,139 @@
+import { TimeInput } from "../common/Time.mjs";
+import { Exception } from "../common/Exception.mjs";
+import { SpanAttributeValue, SpanAttributes } from "./attributes.mjs";
+import { SpanContext } from "./span_context.mjs";
+import { SpanStatus } from "./status.mjs";
+import { Link } from "./link.mjs";
+//#region src/trace/span.d.ts
+/**
+ * An interface that represents a span. A span represents a single operation
+ * within a trace. Examples of span might include remote procedure calls or a
+ * in-process function calls to sub-components. A Trace has a single, top-level
+ * "root" Span that in turn may have zero or more child Spans, which in turn
+ * may have children.
+ *
+ * Spans are created by the {@link Tracer.startSpan} method.
+ *
+ * @since 1.0.0
+ */
+interface Span {
+  /**
+   * Returns the {@link SpanContext} object associated with this Span.
+   *
+   * Get an immutable, serializable identifier for this span that can be used
+   * to create new child spans. Returned SpanContext is usable even after the
+   * span ends.
+   *
+   * @returns the SpanContext object associated with this Span.
+   */
+  spanContext(): SpanContext;
+  /**
+   * Sets an attribute to the span.
+   *
+   * Sets a single Attribute with the key and value passed as arguments.
+   *
+   * @param key the key for this attribute.
+   * @param value the value for this attribute. Setting a value null or
+   *              undefined is invalid and will result in undefined behavior.
+   */
+  setAttribute(key: string, value: SpanAttributeValue): this;
+  /**
+   * Sets attributes to the span.
+   *
+   * @param attributes the attributes that will be added.
+   *                   null or undefined attribute values
+   *                   are invalid and will result in undefined behavior.
+   */
+  setAttributes(attributes: SpanAttributes): this;
+  /**
+   * Adds an event to the Span.
+   *
+   * @param name the name of the event.
+   * @param [attributesOrStartTime] the attributes that will be added; these are
+   *     associated with this event. Can be also a start time
+   *     if type is {@type TimeInput} and 3rd param is undefined
+   * @param [startTime] start time of the event.
+   */
+  addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
+  /**
+   * Adds a single link to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param link the link to add.
+   *
+   * @since 1.9.0
+   */
+  addLink(link: Link): this;
+  /**
+   * Adds multiple links to the span.
+   *
+   * Links added after the creation will not affect the sampling decision.
+   * It is preferred span links be added at span creation.
+   *
+   * @param links the links to add.
+   *
+   * @since 1.9.0
+   */
+  addLinks(links: Link[]): this;
+  /**
+   * Sets the status of the span.
+   *
+   * By default, a span has status {@link SpanStatusCode.UNSET}.
+   * Calling this method overrides that default.
+   *
+   * The status codes have a total order: `OK > ERROR > UNSET`.
+   *
+   * - Once {@link SpanStatusCode.OK} is set, any further attempts to change
+   *   the status are ignored.
+   * - Any attempt to set {@link SpanStatusCode.UNSET} is always ignored.
+   *
+   * The `message` field is only used when {@link SpanStatusCode.ERROR} is set.
+   * For all other status codes, `message` is ignored.
+   *
+   * @param status The {@link SpanStatus} to set.
+   */
+  setStatus(status: SpanStatus): this;
+  /**
+   * Updates the Span name.
+   *
+   * This will override the name provided via {@link Tracer.startSpan}.
+   *
+   * Upon this update, any sampling behavior based on Span name will depend on
+   * the implementation.
+   *
+   * @param name the Span name.
+   */
+  updateName(name: string): this;
+  /**
+   * Marks the end of Span execution.
+   *
+   * Call to End of a Span MUST not have any effects on child spans. Those may
+   * still be running and can be ended later.
+   *
+   * Do not return `this`. The Span generally should not be used after it
+   * is ended so chaining is not desired in this context.
+   *
+   * @param [endTime] the time to set as Span's end time. If not provided,
+   *     use the current time as the span's end time.
+   */
+  end(endTime?: TimeInput): void;
+  /**
+   * Returns the flag whether this span will be recorded.
+   *
+   * @returns true if this Span is active and recording information like events
+   *     with the `AddEvent` operation and attributes using `setAttributes`.
+   */
+  isRecording(): boolean;
+  /**
+   * Sets exception as a span event
+   * @param exception the exception the only accepted values are string or Error
+   * @param [time] the time to set as Span's event time. If not provided,
+   *     use the current time.
+   */
+  recordException(exception: Exception, time?: TimeInput): void;
+}
+//#endregion
+export { Span };
+//# sourceMappingURL=span.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/span.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.mts","names":[],"sources":["../../src/trace/span.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAiBiB;;;;;;;;;;EAUb,eAAe;;;;;;;;;;EAUf,aAAa,aAAa,OAAO;;;;;;;;EAQjC,cAAc,YAAY;;;;;;;;;;EAU1B,SAAS,cAAc,wBAAwB,iBAAiB,WAAW,YAAY;;;;;;;;;;;EAWvF,QAAQ,MAAM;;;;;;;;;;;EAWd,SAAS,OAAO;;;;;;;;;;;;;;;;;;EAkBhB,UAAU,QAAQ;;;;;;;;;;;EAWlB,WAAW;;;;;;;;;;;;;EAaX,IAAI,UAAU;;;;;;;EAOd;;;;;;;EAOA,gBAAgB,WAAW,WAAW,OAAO"}

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.cts

@@ -0,0 +1,58 @@
+import { TraceState } from "./trace_state.cjs";
+//#region src/trace/span_context.d.ts
+/**
+ * A SpanContext represents the portion of a {@link Span} which must be
+ * serialized and propagated along side of a {@link Baggage}.
+ *
+ * @since 1.0.0
+ */
+interface SpanContext {
+  /**
+   * The ID of the trace that this span belongs to. It is worldwide unique
+   * with practically sufficient probability by being made as 16 randomly
+   * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+   * 128 bits.
+   */
+  traceId: string;
+  /**
+   * The ID of the Span. It is globally unique with practically sufficient
+   * probability by being made as 8 randomly generated bytes, encoded as a 16
+   * lowercase hex characters corresponding to 64 bits.
+   */
+  spanId: string;
+  /**
+   * Only true if the SpanContext was propagated from a remote parent.
+   */
+  isRemote?: boolean;
+  /**
+   * Trace flags to propagate.
+   *
+   * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+   * sampled or not. When set, the least significant bit documents that the
+   * caller may have recorded trace data. A caller who does not record trace
+   * data out-of-band leaves this flag unset.
+   *
+   * see {@link TraceFlags} for valid flag values.
+   */
+  traceFlags: number;
+  /**
+   * Tracing-system-specific info to propagate.
+   *
+   * The tracestate field value is a `list` as defined below. The `list` is a
+   * series of `list-members` separated by commas `,`, and a list-member is a
+   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+   * surrounding `list-members` are ignored. There can be a maximum of 32
+   * `list-members` in a `list`.
+   * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+   *
+   * Examples:
+   *     Single tracing system (generic format):
+   *         tracestate: rojo=00f067aa0ba902b7
+   *     Multiple tracing systems (with different formatting):
+   *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+   */
+  traceState?: TraceState;
+}
+//#endregion
+export { SpanContext };
+//# sourceMappingURL=span_context.d.cts.map

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_context.d.cts","names":[],"sources":["../../src/trace/span_context.d.ts"],"mappings":";;;;;;;;UAOiB;;;;;;;EAOb;;;;;;EAMA;;;;EAIA;;;;;;;;;;;EAWA;;;;;;;;;;;;;;;;;EAiBA,aAAa"}

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.mts

@@ -0,0 +1,58 @@
+import { TraceState } from "./trace_state.mjs";
+//#region src/trace/span_context.d.ts
+/**
+ * A SpanContext represents the portion of a {@link Span} which must be
+ * serialized and propagated along side of a {@link Baggage}.
+ *
+ * @since 1.0.0
+ */
+interface SpanContext {
+  /**
+   * The ID of the trace that this span belongs to. It is worldwide unique
+   * with practically sufficient probability by being made as 16 randomly
+   * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+   * 128 bits.
+   */
+  traceId: string;
+  /**
+   * The ID of the Span. It is globally unique with practically sufficient
+   * probability by being made as 8 randomly generated bytes, encoded as a 16
+   * lowercase hex characters corresponding to 64 bits.
+   */
+  spanId: string;
+  /**
+   * Only true if the SpanContext was propagated from a remote parent.
+   */
+  isRemote?: boolean;
+  /**
+   * Trace flags to propagate.
+   *
+   * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+   * sampled or not. When set, the least significant bit documents that the
+   * caller may have recorded trace data. A caller who does not record trace
+   * data out-of-band leaves this flag unset.
+   *
+   * see {@link TraceFlags} for valid flag values.
+   */
+  traceFlags: number;
+  /**
+   * Tracing-system-specific info to propagate.
+   *
+   * The tracestate field value is a `list` as defined below. The `list` is a
+   * series of `list-members` separated by commas `,`, and a list-member is a
+   * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+   * surrounding `list-members` are ignored. There can be a maximum of 32
+   * `list-members` in a `list`.
+   * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+   *
+   * Examples:
+   *     Single tracing system (generic format):
+   *         tracestate: rojo=00f067aa0ba902b7
+   *     Multiple tracing systems (with different formatting):
+   *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+   */
+  traceState?: TraceState;
+}
+//#endregion
+export { SpanContext };
+//# sourceMappingURL=span_context.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/span_context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_context.d.mts","names":[],"sources":["../../src/trace/span_context.d.ts"],"mappings":";;;;;;;;UAOiB;;;;;;;EAOb;;;;;;EAMA;;;;EAIA;;;;;;;;;;;EAWA;;;;;;;;;;;;;;;;;EAiBA,aAAa"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.cjs

@@ -0,0 +1,35 @@
+//#region src/trace/span_kind.ts
+/**
+* @since 1.0.0
+*/
+let SpanKind = /* @__PURE__ */ function(SpanKind) {
+	/** Default value. Indicates that the span is used internally. */
+	SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+	/**
+	* Indicates that the span covers server-side handling of an RPC or other
+	* remote request.
+	*/
+	SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+	/**
+	* Indicates that the span covers the client-side wrapper around an RPC or
+	* other remote request.
+	*/
+	SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+	/**
+	* Indicates that the span describes producer sending a message to a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+	/**
+	* Indicates that the span describes consumer receiving a message from a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+	return SpanKind;
+}({});
+//#endregion
+exports.SpanKind = SpanKind;
+
+//# sourceMappingURL=span_kind.cjs.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.cjs","names":[],"sources":["../../src/trace/span_kind.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @since 1.0.0\n */\nexport enum SpanKind {\n  /** Default value. Indicates that the span is used internally. */\n  INTERNAL = 0,\n\n  /**\n   * Indicates that the span covers server-side handling of an RPC or other\n   * remote request.\n   */\n  SERVER = 1,\n\n  /**\n   * Indicates that the span covers the client-side wrapper around an RPC or\n   * other remote request.\n   */\n  CLIENT = 2,\n\n  /**\n   * Indicates that the span describes producer sending a message to a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  PRODUCER = 3,\n\n  /**\n   * Indicates that the span describes consumer receiving a message from a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  CONSUMER = 4,\n}\n"],"mappings":";;;;AAQA,IAAY,WAAL,yBAAA,UAAA;;CAEL,SAAA,SAAA,cAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;AACF,EAAA,CAAA,CAAA"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.cts

@@ -0,0 +1,33 @@
+//#region src/trace/span_kind.d.ts
+/**
+ * @since 1.0.0
+ */
+declare enum SpanKind {
+  /** Default value. Indicates that the span is used internally. */
+  INTERNAL = 0,
+  /**
+   * Indicates that the span covers server-side handling of an RPC or other
+   * remote request.
+   */
+  SERVER = 1,
+  /**
+   * Indicates that the span covers the client-side wrapper around an RPC or
+   * other remote request.
+   */
+  CLIENT = 2,
+  /**
+   * Indicates that the span describes producer sending a message to a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  PRODUCER = 3,
+  /**
+   * Indicates that the span describes consumer receiving a message from a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  CONSUMER = 4
+}
+//#endregion
+export { SpanKind };
+//# sourceMappingURL=span_kind.d.cts.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.d.cts","names":[],"sources":["../../src/trace/span_kind.d.ts"],"mappings":";;;;aAGoB;;EAEhB;;;;;EAKA;;;;;EAKA;;;;;;EAMA;;;;;;EAMA"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.mts

@@ -0,0 +1,33 @@
+//#region src/trace/span_kind.d.ts
+/**
+ * @since 1.0.0
+ */
+declare enum SpanKind {
+  /** Default value. Indicates that the span is used internally. */
+  INTERNAL = 0,
+  /**
+   * Indicates that the span covers server-side handling of an RPC or other
+   * remote request.
+   */
+  SERVER = 1,
+  /**
+   * Indicates that the span covers the client-side wrapper around an RPC or
+   * other remote request.
+   */
+  CLIENT = 2,
+  /**
+   * Indicates that the span describes producer sending a message to a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  PRODUCER = 3,
+  /**
+   * Indicates that the span describes consumer receiving a message from a
+   * broker. Unlike client and server, there is no direct critical path latency
+   * relationship between producer and consumer spans.
+   */
+  CONSUMER = 4
+}
+//#endregion
+export { SpanKind };
+//# sourceMappingURL=span_kind.d.mts.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.d.mts","names":[],"sources":["../../src/trace/span_kind.d.ts"],"mappings":";;;;aAGoB;;EAEhB;;;;;EAKA;;;;;EAKA;;;;;;EAMA;;;;;;EAMA"}

package/node_modules/@opentelemetry/api/dist/trace/span_kind.mjs

@@ -0,0 +1,35 @@
+//#region src/trace/span_kind.ts
+/**
+* @since 1.0.0
+*/
+let SpanKind = /* @__PURE__ */ function(SpanKind) {
+	/** Default value. Indicates that the span is used internally. */
+	SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+	/**
+	* Indicates that the span covers server-side handling of an RPC or other
+	* remote request.
+	*/
+	SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+	/**
+	* Indicates that the span covers the client-side wrapper around an RPC or
+	* other remote request.
+	*/
+	SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+	/**
+	* Indicates that the span describes producer sending a message to a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+	/**
+	* Indicates that the span describes consumer receiving a message from a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+	return SpanKind;
+}({});
+//#endregion
+export { SpanKind };
+
+//# sourceMappingURL=span_kind.mjs.map

package/node_modules/@opentelemetry/api/dist/trace/span_kind.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"span_kind.mjs","names":[],"sources":["../../src/trace/span_kind.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @since 1.0.0\n */\nexport enum SpanKind {\n  /** Default value. Indicates that the span is used internally. */\n  INTERNAL = 0,\n\n  /**\n   * Indicates that the span covers server-side handling of an RPC or other\n   * remote request.\n   */\n  SERVER = 1,\n\n  /**\n   * Indicates that the span covers the client-side wrapper around an RPC or\n   * other remote request.\n   */\n  CLIENT = 2,\n\n  /**\n   * Indicates that the span describes producer sending a message to a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  PRODUCER = 3,\n\n  /**\n   * Indicates that the span describes consumer receiving a message from a\n   * broker. Unlike client and server, there is no direct critical path latency\n   * relationship between producer and consumer spans.\n   */\n  CONSUMER = 4,\n}\n"],"mappings":";;;;AAQA,IAAY,WAAL,yBAAA,UAAA;;CAEL,SAAA,SAAA,cAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;CAMA,SAAA,SAAA,YAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;;;;;CAOA,SAAA,SAAA,cAAA,KAAA;;AACF,EAAA,CAAA,CAAA"}